Some specific project requirements make it necessary to push records for the Journey in SFMC directly from the Salesforce CRM. When the Salesforce Data entry source is not able to cover it as needed, I recommend using REST API callout from the Salesforce CRM.

Now you have 2 options for how to do it:

• via Flow
• via Apex Trigger

In this article, you will find detailed instructions on how to do it usingApex Trigger.

Step 1. Configuring the REST API package.

We need to be sure the REST API package is configured properly in the SFMC.

IMPORTANT: If you are using several Business Units, you’ll need to provide access to the REST API package for all of them as shown in the screenshot:

Step 2. Adding the Data Extension.

I recommend building your email template (or other marking content) and adding a Data Extension with all of the necessary attributes. As soon as the Data Extension is created, we’ll be able to build the Journey.

Step 3. Creating a Journey.

We need to select the type of the journey and select the Entry Source (in our case it’s API Event):

The target Data Extension is the one we created previously.

Here it is important to understand that in our REST API callout, we will use the EVENT DEFINITION KEY from the Journey.

Add all of the necessary activities to the Journey, then click “Save”, “Validate” and “Activate”.

When the Journey is created, we can switch to the Salesforce CRM and set up the Apex trigger.

Step 4. Setting up the trigger in Apex.

First of all, we need to understand when a new record should enter the Journey to select the correct trigger type.

We need to make 2 different callouts from Apex:

• To take the token
• To trigger the Journey

Here is a basic example of an Apex Class that you can reuse with your specific adjustments:

public with sharing class MC_EmailSendService {

    public static MARKETING_CLOUD_SETTINGS__c marketingCloudSettings = MARKETING_CLOUD_SETTINGS__c.getOrgDefaults();
    public static final String EventDefinitionKey = 'SendConfirmationEmail';

    public static void sendEventTOSFMC(final String recordId, final String email) {
        String token = getToken();
        Map<String, String> tokenData = (Map<String,String>) JSON.deserialize(token, Map<String,String>.class);
        CalloutWebService.sendRequestMC(
                marketingCloudSettings.APP_EVENT_URL__c,
                'POST',
                'application/json',
                tokenData.get('access_token'),
                getRequestBodyToSendEvent(recordId, email)
        );
    }

    private static String getToken() {
        HttpResponse resp = CalloutWebService.sendRequestMC(
                marketingCloudSettings.API_TOKEN_URL__c,
                'POST',
                'application/json',
                getRequestBody()
        );
        return resp.getBody();
    }

    private static String getRequestBody() {
        JSONGenerator gen = JSON.createGenerator(true);
        gen.writeStartObject();
        gen.writeStringField('grant_type', marketingCloudSettings.GRANT_TYPE__c);
        gen.writeStringField('client_id', marketingCloudSettings.CLIENT_ID__c);
        gen.writeStringField('client_secret', marketingCloudSettings.CLIENT_SECRET__c);
        gen.writeStringField('account_id', marketingCloudSettings.ACCOUNT_ID__c);
        gen.writeEndObject();
        return gen.getAsString();
    }

    private static String getRequestBodyToSendEvent(final String recordId, final String email) {
        return JSON.serialize(new Map<String, Object>{
                    'ContactKey' => recordId,
                    'EventDefinitionKey' => EventDefinitionKey,
                    'Data' => new Map<String, Object>{
                            'subscriberKey' => recordId,
                            'email' => email                    }
        });
    }
}

I recommend storing all of the static data for the callouts in the Custom settings or the Named Credentials. In this example, I am using MARKETING_CLOUD_SETTINGS__c for Custom Settings.

Step 5. Testing the API connection.

To test the REST API callouts, I recommend using Postman.

1. To get the Token.

POST = https://YOUR_SUBDOMAIN.auth.marketingcloudapis.com/v2/token

YOUR_SUBDOMAIN = Authentication Base URI from your REST API package

Content-Type = application/json

Body = type raw

{"grant_type": "client_credentials",
"client_id": "client_id",
"client_secret": "client_secret",
"account_id": "your_MID"
}

client_id = the Client ID value from the REST API package

client_ secret = the Client Secret value from the REST API package

account_id = the MID you can find in your header:

It is important to define it if you are using multiple Business Units. If you are using just one Business Unit, you can proceed without the account_id.

Status 200 OK

Response:

{
"access_token": "eyJhbGciOiJIUzI1NiIsImtpZCI6IjQiLCJ2ZXIiOiIxIiwidHlwIjoiSldUIn0.eyJhY2Nlc3NfdG9rZW4iOiJYNUFMU29Mb0Z4b0swZElMSjZDdXBva0YiLCJjbGllbnRfaWQiOiI1dzEyNmRnOGRsOW5wY2x4ZjV4bWlra3oiLCJlaWQiOjUxMDAwNDUxOSwic3RhY2tfa2V5IjoiUzUwIiwicGxhdGZvcm1fdmVyc2lvbiI6MiwiY2xpZW50X3R5cGUiOiJTZXJ2ZXJUb1NlcnZlciIsInBpZCI6NzI3fQ.4iCCytkVPD39z0CjXmZvG_2vZbSd6fUGrMc7Mf4oABg.7DIKoT1qVFnRzT5c9y0Y6nGEIGdRmqEZOraRAAJowKsQ7zEkiwZbLh_ti8Qj9elkUmCYrlpOIFKQ8GaG2FRXaA2STAj89F9qKfJIYw_d9UXNLK2h0BFRwc7fk5qg1FXKlSK2kKjgaF4BLYVnBb1Ds_sguauntZj8QYo6H",
"token_type": "Bearer",
"expires_in": 1079,
"scope": "offline documents_and_images_read documents_and_images_write saved_content_read saved_content_write automations_execute automations_read automations_write journeys_execute journeys_read journeys_write email_read email_send email_write push_read push_send push_write sms_read sms_send sms_write social_post social_publish social_read social_write web_publish web_read web_write audiences_read audiences_write list_and_subscribers_read list_and_subscribers_write data_extensions_read data_extensions_write file_locations_read file_locations_write tracking_events_read calendar_read calendar_write campaign_read campaign_write accounts_read accounts_write users_read users_write webhooks_read webhooks_write workflows_write approvals_write tags_write approvals_read tags_read workflows_read ott_chat_messaging_read ott_chat_messaging_send ott_channels_read ott_channels_write marketing_cloud_connect_read marketing_cloud_connect_write marketing_cloud_connect_send event_notification_callback_create event_notification_callback_read event_notification_callback_update event_notification_callback_delete event_notification_subscription_create event_notification_subscription_read event_notification_subscription_update event_notification_subscription_delete tracking_events_write key_manage_view key_manage_rotate key_manage_revoke dfu_configure journeys_aspr journeys_delete package_manager_package package_manager_deploy deep_linking_asset_read deep_linking_asset_write deep_linking_asset_delete deep_linking_settings_read deep_linking_settings_write market_audience_create market_audience_view market_audience_update market_audience_delete market_audience_member_create market_audience_member_view market_audience_member_update market_audience_member_delete contact_bu_mapping_create contact_bu_mapping_view contact_bu_mapping_update contact_bu_mapping_delete http_headers_view http_headers_update http_headers_delete e360_analytics_provisioning_view e360_analytics_provisioning_update e360_analytics_provisioning_delete",
"soap_instance_url": "https://domain.soap.marketingcloudapis.com/",
"rest_instance_url": "https://domain.rest.marketingcloudapis.com/"
}

You need to use access_token in the next callout.

IMPORTANT: The token is valid for 20 minutes only.

2. To trigger the Journey.

POST = https://YOUR_SUBDOMAIN.rest.marketingcloudapis.com/interaction/v1/events

YOUR_SUBDOMAIN = Authentication Base URI from your REST API Package

Content-Type = application/json

Body = type raw

{
"ContactKey": "003…",
"EventDefinitionKey": "APIEvent-d052ee82-d4e7-…",
"Data": {
"subscriberKey": "003…",
"email": "ademchuk@noltic.com"
}
}

EventDefinitionKey = your EVENT DEFINITION KEY from the Journey.

This target Data Extension contains only 2 fields — subscriberKey and email, but you can add as many as you want based on your business requirements.

After running the command, a new record should appear in the target Data Extension and the Journey should be triggered as well.

After your Apex class is finished and you make sure that everything works fine, do not forget to add the Apex test class as well. As a rule of thumb, I recommend adding the Apex test class first.

That’s it — the records will be pushed to the Journey from the Salesforce CRM automatically now. Let me know if the article was helpful and stay tuned for new Salesforce Marketing Cloud tips and tutorials.

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

Setting up a trigger-based Journey from the Salesforce CRM via REST API — Salesforce Marketing… was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Cloud File Uploader is an AppExchange product that allows Salesforce file upload from different sources. A solution like this holds great potential for businesses — it helps combine data from various systems, applications, or cloud-based services, providing a comprehensive view of operations and customers.

When uploading data into Salesforce, Cloud File Uploader also ensures its consistency and accuracy. A solution like that eliminates the risk of working with outdated or duplicated files by synchronizing information across different sources. This helps businesses maintain a single version of the truth, enhancing decision-making and avoiding confusion or misunderstandings caused by conflicting data.

Businesses running on Salesforce usually have at least one of two problems:

1. How to upload files to Salesforce from multiple sources?
2. How to link files stored outside of Salesforce to the records in the system?

Cloud File Uploader solves both of those problems. It allows uploading files from multiple sources to Salesforce or external storage with the ability to link them to Salesforce records.

The ability to link files from different sources that comes with Cloud File Uploader allows for saving Salesforce file storage. It also promotes efficient collaboration across teams and departments that use different platforms — they can easily share, access, and work on files regardless of their initial source or location. This eliminates the need for manual file transfers, reducing errors and saving time.

What’s New

In the new version of Cloud File Uploader, the API has been updated to make the process of uploading files to external storage faster and more secure. We use the Uploadcare platform to store files. The configuration of Uploadcare allows the files to be alternatively stored on S3. To allow users to view and manage their remote files from Salesforce, we provide the functionality that uses the link to file preview, and a new API allows users to delete files from the cloud from Salesforce.

Full list of features & functionality

• Native Salesforce solution
• Upload files into Salesforce from 12 different sources, including all the popular cloud storage providers (Facebook, Google Drive, Google Photos, Dropbox, Instagram, Evernote, Flickr, OneDrive, Box, Huddle)
• A no-code solution to store locally in Salesforce linked to Salesforce records
• Native Salesforce Lightning file uploader for local files, allowing you to upload files up to 2GB
• Secure file upload to Salesforce from remote URLs
• No-code solution to store files remotely on the Uploadcare platform (requires an Uploadcare account) and S3 (through Uploadcare)

“With the new release, the ability to store files outside of Salesforce, while leveraging the ability to link those files to records in Salesforce will allow to use Salesforce storage more effectively, and not hog it with the file storage,” says Igor Petrovych, CEO at Noltic

We keep our app up-to-date to incorporate bug fixes and other improvements per client requests. Among the latest features planned to be released is the migration of files from the local storage to a remote location, while maintaining links to records. This will allow Salesforce users of existing orgs to adapt our app very quickly.

Start using Cloud File Uploader for free now.

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

Noltic has released an updated version of a native app for linking and uploading files to… was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Salesforce Marketing Cloud Personalization opens up a whole multiverse of communication journeys tailored to specific customer lifecycles. It provides a level of targeted content delivery hardly ever seen before and helps build strong customer-oriented strategies.

The most popular application of SFMC customization abilities is email marketing with triggered campaigns. Using this guide, you’ll be able to configure dynamically personalized recommendation blocks for customers you want to engage with over email.

Step 1.

Define recipes you will use in the Campaign configuration or Server-Side Triggered Templates to provide recommendations based on some specific parameters depending on your business needs.

Step 2.

Create a Server-Side Triggered Template in Personalization. It is the Server-side Code that allows you to define custom logic as well.

In the Journey Builder Trigger global template, go to the JourneyBuilderTriggeredPayload class. There, you will need to define your recommendations and user Attributes.

Step 3.

Create a target Data Extension in Marketing Cloud. That specific Data Extension should contain the user Attribute defined in the Server-Side Triggered Template in Personalization. Data Extension should be sendable.

Create a field for each user attribute in the event data extension in Salesforce Marketing Cloud. Data extension field names must match user attribute names.

After you select a recipe, create a Recommendations field in the event data extension in Marketing Cloud. Doing so allows you to add a Recommendations block to an email in Marketing Cloud.

Step 4.

Create a Server-Side Campaign. Here you need to define some specifics to ensure you can set up triggers via REST API.

Campaign Targeting:

• Channel contains Server (default one, recommended to keep it as it is);
• Add rule > Action includes Get Recommendation (name of your new purposely created or already existing Event).

Experience:

• Select the target Server-Side Triggered Template;
• User Attributes (one of the identity types) — in our case, I am using emailAddress;
• In the Email Recommendations section, you need to define the previously created recipes.

As a result, your Server-Side Campaign should look like this:

Save and publish it.

Step 5.

Create a code snippet for our email template to send the event to Personalization and get our fresh recommendations from the Server-Side Campaign. The Content will be changed dynamically based on the selected record from the target Data Extension and the result of the Recipe calculation.

You’ll need to make a REST API callout to get the recommendation (I’m using SSJS):

var emailAddress = Attribute.GetValue(‘Email’);
var payload = '{"user": {"attributes": {"emailAddress": ' + '"' + emailAddress + '"' + '}},"source": {"channel": "Server"},"interaction" : {"name": "Get Recommendations"}}';
var req = new Script.Util.HttpRequest
(https://<accountName>.<instance>.evergage.com/api2/authevent/<dataset>');
req.emptyContentHandling = 0;
req.retries = 2;
req.continueOnError = true;
req.contentType = "application/json"
req.setHeader("Authorization", 'Basic {code*}');
req.method = "POST";
req.postData = payload;
var resp = req.send();

//* You need to encode {API Key ID,"API Key Secret"} to Base64 format

Step 6.

Parse the response based on your configurations in the email template, in my case, it looks like this:

var respPayload = Platform.Function.ParseJSON(String(resp.content));
var recommendations = respPayload.campaignResponses[0].payload.Recommendations;
var Catalog_Data = Platform.Function.ParseJSON(recommendations);

I have the result of the REST API Callout saved in the variable Catalog_Data. You need to define the HTML body to preview the recommendation based on your business needs:

This documentation article should be of help during the implementation.

Step 7.

Create a Journey to send emails regularly and schedule them correctly (daily/hourly/weekly/monthly/yearly):

As an Entry Source for the Journey, I am using the Data Extension created in Step 3.

Save, Validate, and Activate your Journey. There you have it!

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

Marketing Cloud Personalization Triggered Campaigns: Personalized emails with dynamically… was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Salesforce Session ID is a crucial piece of authentication and security information used in the Salesforce platform. It is a unique identifier generated by Salesforce when a user logs in and represents an active user session. The Session ID is used to authenticate and authorize a user’s access to Salesforce resources, such as data, APIs, and user interfaces.

Developers often use Session ID when making API calls to Salesforce. The Session ID parameter is included in the HTTP headers of API requests as a form of authentication. This allows external applications and services to interact with Salesforce on behalf of a user without requiring them to log in each time.

Salesforce offers a security review process for applications developed on the platform. This review helps ensure that your application complies with Salesforce’s security policies and best practices of data safety.

During the security review, Salesforce evaluates how your application handles sensitive data, including Session IDs, and checks for vulnerabilities and security flaws.

Today I am going to invite you to go with me through the way I went to get Session ID for our company’s managed packages. To see the pitfalls we’ve met and what we found out.

The approaches to obtaining Session ID

When you’re looking to integrate with a web service or utilize Apex-MDapi, acquiring a Session ID is a key step, as it serves as your Bearer token for authentication purposes. Getting a Session ID can be accomplished through various methods, readily available with a quick online search.

The simplest one is

UserInfo.getSessionId();

When executing it within an anonymous window, the initial challenge you’ll encounter is the inability to view it in the debug log. In most cases, you’ll likely come across an output similar to the following:

|USER_DEBUG|[14]|DEBUG|SESSION_ID_REMOVED

There are a few workarounds to obtain the Session ID value:

Create a new Case record and save the Session ID in the description field. You can then retrieve it from the standard Salesforce user interface.

Case c = new Case(Description = UserInfo.getSessionId());

Execute this code snippet, retrieve the result, and then remove any whitespace.

UserInfo.getOrganizationId().substring(0, 15) + ‘ ‘ + UserInfo.getSessionId().substring(15)

To proceed with making a request, the next step involves retrieving the organization URL in an external format. You can quickly obtain it using the following code snippet:

URL.getOrgDomainUrl().toExternalForm();

With the Session ID and Organization URL in hand, you can leverage tools like Postman along with Salesforce Collections or simply use the Postman Salesforce Workspace to interact with the API and validate the functionality of your Session ID, also known as the token.

In the screenshot below, you’ll find an example illustrating the retrieval of Organization Limits.

Now, everything appears to be in order, and it seems like we can utilize it for our solutions. But there’s always a ‘but’. What if we attempt to use it with our Lightning Web Component? So let’s create a straightforward LWC component with a button and its corresponding Apex controller.

public with sharing class SessionIdController {

@AuraEnabled
 public static String getLimits() {
 String endpoint = Url.getOrgDomainUrl().toExternalForm() + '/services/data/v58.0/limits';
 String bearer = 'Bearer ' + UserInfo.getSessionId();

HttpRequest req = new HttpRequest();
 req.setEndpoint(endpoint);
 req.setMethod('GET');
 req.setHeader('Authorization', bearer);

Http http = new Http();
 HttpResponse res = http.send(req);
 return res.getBody();
 }
}

When we attempt to do this from the LWC component, an error will occur, and the response will resemble what’s shown in the screenshot below:

Executing the same controller’s method in an anonymous window returns the expected response:

Visualforce page approach

In Salesforce, you don’t need to explicitly obtain the Session ID when working with Visualforce pages because the Session ID is automatically available within the context of a Visualforce page. Salesforce handles the authentication and session management for you.

<! — SessionIdPage →
<apex:page contentType=”application/json”>
 {“sessionId”:”{!$Api.Session_ID}”}
</apex:page>

In the example above, the {$Api.Session_ID} expression is used to display the Session ID on the Visualforce page. Salesforce automatically provides this value, and you can access it directly.

So we can use this method to retrieve the Session ID from a Visualforce page. The most prevalent approach to acquire the Session ID securely is by creating a Visualforce page and incorporating a global merge field to extract it from the page.

public class SessionIdService {

public class SessionWrapper {
 public string sessionId;
 }
 @AuraEnabled
 public static string getSessionId() {
 SessionWrapper wrapper = (SessionWrapper) JSON.deserialize(
 Page.SessionIdPage.getContent().toString(),
 SessionWrapper.class
 );
 return wrapper.sessionId;
 }
}

Since this approach works as intended, many developers continue to use it successfully. However, when it comes to incorporating it within a managed package, several considerations and challenges arise.

Session ID, Managed Packages and Security Review

In Salesforce, they really value the trust of their customers. If you’re an independent software vendor (ISV) and want to share your managed package with the public, it has to go through a security review to make sure it’s safe.

We had some doubts about using the Visualforce approach in managed packages. It seemed more like a workaround than an solid solution. So, we set up a meeting with Salesforce Support to talk about our needs and figure out how to do it the right way, following all the security rules.

At Noltic, while creating our managed packages like CheckMyNumber and Tracky, we had some peculiar situations. We needed to connect our web services to give users a better experience. To do this, we used something called Apex-Mdapi as a part of our solution.

Canvas Connected Application

Canvas enables you to integrate a third-party application in Salesforce easily. Canvas is a set of tools and JavaScript APIs that you can use to expose an application as a canvas app. This means you can take your new or existing applications and make them available to your users as part of their Salesforce experience.

When you use a signed request for authentication in your canvas app, you receive a CanvasRequest object in the initial POST message from Salesforce. This object contains a lot of information about the Client and Context. The Client object has an oauth token so all other aspects we can handle from the service side.

There are some steps in order to create a Canvas Connected Application:

• Callback URL is a required field, as we don’t use it and can’t leave it empty we can put in some dummy URL
• In the Canvas Setting section, we need to specify our web service URL and select Access Method: Signed Request (POST)

We’ve achieved successful integration using Canvas for our CheckMyNumber application.

Connected Application for Apex-Mdapi

In our products, we had specific processes to implement, and we chose Apex-Mdapi for this purpose. Following Salesforce’s guidance, we explored authentication options for connected apps and selected OAuth 2.0 JWT Bearer Flow for Server-to-Server due to its lack of user interaction. The central idea is to utilize a connected app as a token provider, include it in the managed package, and use it in subscriber organizations.

The first step is generating a certificate

# Generate an RSA private key
openssl genrsa -des3 -passout pass:x -out server.pass.key 2048

# Create a key file from the server.pass.key file
openssl rsa -passin pass:x -in server.pass.key -out server.key

# Request and generate the certificate
openssl req -new -key server.key -out server.csr

# Generate the SSL certificate
openssl x509 -req -sha256 -days 365 -in server.csr -signkey server.key -out server.crt

Afterwards, we need to create a connected app

Then do these steps:

• Go to Setup > Connected app > New.
• Fill in Name and Email
• Click on ‘Enable OAuth Setting’
• Call back URL ‘https://login.salesforce.com’
• Click on ‘Use Digital Signature’ and upload the certificate created.
• Select the following OAuth Scopes — Manage user data via APIs (api), Perform requests at any time (refresh_token, offline_access)
• Click on ‘Save’

JWT Flow Using Apex

We’ve set up the connected app, and we can finally use Apex code to obtain the access token.

There is some data that you need in order to perform the request.

Headers:

{“alg”:”RS256"}

Payload: Data

{
 “iss” : “Connected App Consumer Key”,
 “sub”: “CurrentUserName”,
 “aud”: “https://login.salesforce.com" or “https://test.salesforce.com",
 “exp”: now + 5minutes
}

Then your request should look like this:

Method: POST

URL: https://login.salesforce.com/services/oauth2/token or https://test.salesforce.com/services/oauth2/token (scratch org or sandbox)

Headers: ‘Content-type’, ‘application/x-www-form-urlencoded’

Body:

• grand_type : urn:ietf:params:oauth:grant-type
• assertion : JWT TOKEN

With the code below we can generate a JWT and make a call to acquire a Salesforce access token. Don’t forget to add login.salesforce.com and test.salesforce.com to your remote site settings as we’ll be using them as endpoints.

public String base64UrlEncode(Blob input){
 String output = EncodingUtil.base64Encode(input);
 output = output.replace(‘+’, ‘-’);
 output = output.replace(‘/’, ‘_’);
 while ( output.endsWith(‘=’)){
 output = output.substring(0,output.length()-1);
 }
 return output;
 }
 
 String getJWT(
 String iss, 
 String sub, 
 String aud, 
 String privateKey) 
 {
 String encodedHeader = base64UrlEncode(
 Blob.valueOf(
 JSON.serialize(new Map<String, String> {‘alg’ => ‘RS256’})
 )
 );

String encodedBody = base64UrlEncode(
 Blob.valueOf(
 JSON.serialize(new Map<String, Object> {
 'iss' => iss,
 'sub' => sub,
 'aud' => aud,
 'exp' => Datetime.now().getTime()/1000 + 300
 })
 )
 );

 String jwt = encodedHeader + '.' + encodedBody;
 Blob signature = Crypto.sign(
 'rsa-sha256',
 Blob.valueOf(jwt),
 EncodingUtil.base64Decode(privateKey)
 );

 jwt += '.' + base64UrlEncode(signature);
 return jwt;
 }

There are only a couple of steps left to do. Or rather, there are only manual steps left that our subscribers need to do after the installation of our 1GP manage packages:

Set up Permitted users to ‘Admin approved users are pre-authorized’

Add profiles that are supposed to use your connected app

In conclusion, the Salesforce Session ID is a vital component for authentication and security within the Salesforce platform. It serves as a unique identifier representing an active user session and is essential for accessing Salesforce resources, making API calls, and interacting with the platform on behalf of users.

Obtaining the Session ID can be achieved through various methods. However, when working with managed packages and security considerations, developers should carefully evaluate their approach.

It’s essential to follow Salesforce’s security guidelines and consider the specific needs of your application when choosing the most appropriate method for obtaining and utilizing the Session ID.

This is Noltic’s approach for 1gp-managed packages and Session ID, I really hope it helps others working with Salesforce.

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

How to get Session ID for Salesforce managed packages was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

In Salesforce Marketing Cloud, a Sender profile is a necessary attribute for message distribution. It is the person included in the ‘From’ section of the message and is the main corporate communication representative for the client.

To personalize the customer experience, a marketer or whoever manages the communication with the clients can choose dynamic contact data to include in the ‘From’ field of their message. This is quite useful in cases of previous personal communication between a specific customer and their CS representative or account owner.

Marketing Cloud allows for creating a dynamic Sender profile to dynamically match each customer with a corresponding contact person’s details. If a customer decides to reply, their response will also be sent to the person in the initial email ‘From’ field. Let’s see how it’s done.

How to create a dynamic Sender profile

1. To create a Data Extension Sender profile, you must have 2 fields in data extension: From_Name and From_Email.

2. After, you must have 2 Code Snippets — ‘Dynamic From Email’ and ‘Dynamic From Name’.

Sample AMPScript to put into the Code Snippet Content Block which assumes the source for the send has an attribute in the target Data Extension titled ‘From_Name’:

%%[
VAR @fromName
SET @fromName = [From_Name]
]%%

Create a separate code snippet for an attribute in the target Data Extension titled ‘From_Email’.

%%[
VAR @fromEmail
SET @fromEmail = [From_Email]
]%%

3. After that, we go to Setup > Feature Settings >Email Studio > Sender Profiles.

We choose ‘Dynamic SP’.

4. Fill out the Sender Profile From Name and From Email fields:

After ‘ContentBlockByKey’ should be the key for our code snippets, which we created early.

To get our Code Snippet, we must open our Code Snippets and copy the Customer Key. The format should look like this:

%%=ContentBlockByKey(“CustomerKey”) =%%

After that, click ‘Save’ in the Sender Profile.

5. Now, when sending emails, select ‘Dynamic SP’ in the Sender Profile. All done!

How to use Reply Mail Management

After mastering the dynamic Sender profile, we should set up a scenario for a customer’s reply. When responding to a dynamically sent email, the response should be sent immediately to the user from whom the initial email was sent.

To use the ‘Reply Mail Management’ feature, you need to have 2 fields in data extension: Reply_Name and Reply_Email.

Go to Setup > Feature Settings > Email Studio > Reply Mail Management. Go to ‘Populate Reply-to Address Dynamically’. Now, put %%Reply_Name%% in ‘Reply Name’, and in Reply Email — %%Reply_Email%%.

That’s it, now the customers will be receiving their emails from a familiar account, and their replies will be handled by the best suitable team member!

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

Matching the sender with the recipient: Dynamic Sender profile and Reply Mail Management in SFMC was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Synchronizing Subscriber data between Salesforce Sales Cloud and Marketing Cloud is not only used to literally extract the data from one place and put it into the other. It’s also a great opportunity to perform a simultaneous validity check of the contact base in the CRM.

To update the Subscribers data in the Marketing Cloud Data Extension and get a list of failed attempts often caused by the emails being invalid, we’ll need to follow these steps:

1. Create Data Extension
2. Automation: Get Records from SFDC
3. Automation: Extract All Subscribers
4. Automation: Export All Subscribers
5. Automation: Update All Subscribers

Also, to get started, we need to create an FTP Account (file transfer protocol account) for transferring files with a host computer using FTP services, which we will use in the Automation process. To do this, go to Setup > Administration > Data Management > FTP Accounts. Then, in FTP Accounts, click on ‘Create User’.

Create Data Extension

Let’s create a Data Extension with the necessary fields and name it ‘All Subscribers Data’. For example, we can create a Data Extension with three fields:

• Subscriber Key;
• Status (subscription status);
• Email Address (subscriber email).

We will store our data about subscribers in it, including their email address and subscription status from Sales Cloud.

Automation: Get Record From SFDC

Next, navigate to the Automation Studio in Journey Builder and create a new automation named ‘Update All Subscribers’.

Next, let’s go to the workflow, where we can see all the activities that we can add to the automation. Choose the ‘SQL Query’ activity and drag it to the right on Canvas.

In the Choose SQL Query Activity section, click ‘Create New Query Activity’.

Enter the name of the Query Activity as ‘Get Records from SFDC’. In the Folder Location, select the folder where the query will be saved. Then, click ‘Next’.

In the QUERY step, enter the following SQL query to retrieve saved data about subscribers from Sales Cloud in Data Extension.

SELECT
sfdc.Id as [Subscriber Key],
sfdc.Email as [Email Address],
CASE
WHEN sfdc.HasOptedOutOfEmail = 'FALSE' THEN 'active' ELSE 'unsubscribe' 
END AS Status
FROM
[Lead_Salesforce] as sfdc
WHERE
sfdc.Email IS NOT NULL
AND
sfdc.HasOptedOutOfEmail IS NOT NULL
UNION
SELECT
sfdc1.Id as [Subscriber Key],
sfdc1.Email as [Email Address],
CASE
WHEN sfdc1.HasOptedOutOfEmail = 'FALSE' THEN 'active' ELSE 'unsubscribe' 
END AS Status
FROM
[Contact_Salesforce] as sfdc1
WHERE
sfdc1.Email IS NOT NULL
AND
sfdc1.HasOptedOutOfEmail IS NOT NULL

We have saved subscribers’ data from both Lead and Contact objects in Sales Cloud. In the Data Extension, the field Status corresponds to ‘HasOptedOutOfEmail’ in Sales Cloud. If the value of ‘HasOptedOutOfEmail’ is ‘False’, the Status is considered ‘Active’; otherwise, it is considered ‘Unsubscribed’.

Then, click ‘Next’.

In Data Extensions, select ‘All Subscribers Data’, which we have created. In the Data Action choose ‘Update’ to ensure the data isn’t overwritten and is constantly updated. Then, click ‘Next’.

In summary, check the input data and click ‘Finish’.

Automation: Extract All Subscribers

Select the ‘Data Extract’ activity and drag it to the right on the Canvas.

After clicking ‘Create New Data Extract Activity’, click ‘Choose’ in Data Extract.

In Properties, enter ‘Extract All Subscribers’ in the ‘Name’ field. For the ‘File Naming Pattern’, provide a file name, for example, ‘ImportAllSub’. In the ‘Extract Type’ field, select ‘Data Extension Extract’. Then, click ‘Next’.

In the Configuration section, select ‘Has Column Headers’ and enter a ‘,’ (comma) in the Column Delimiter field. For the DECustomer Key, enter the External Key Data Extension we created earlier. Then, click ‘Next’.

In summary, check the input data and click ‘Finish’.

Automation: Export All Subscribers

Select the ‘File Transfer’ activity and drag it to the right on the Canvas.

After clicking ‘Create New File Transfer Activity’, click ‘Choose’ in File Transfer.

In the Properties section, fill in the Name field with ‘Export All Subscribers’. Choose ‘Move a File From Safehouse’ as the File Action, then click ‘Next’.

In the Configuration section, input ‘ImportAllSub’ into the File Naming Pattern field, which refers to the same file created during the ‘Data Extract’ step. For the ‘Destination’, select ‘ExactTarget Enhanced FTP’, and then proceed by clicking ‘Next’.

In summary, check the input data and click ‘Finish’.

Automation: Update All Subscribers

Select the ‘Import File’ activity and drag it to the right on the Canvas.

Click ‘Choose’ in the Import File, after clicking ‘Create New Import Definition’.

In the Properties section, enter ‘Update All Subscribers’ in the ‘Name’ field. If you want to receive emails with this data in .txt format, select ‘Send notification email to:’ and provide your email address.

Finally, click ‘Next’.

In the Import File section, select ‘ExactTarget Enhanced FTP’ as the File Location.

Enter ‘ImportAllSub’ in the File Naming Pattern field. On the right-hand side, in the ‘Delimiter’ section, choose ‘Comma’. Make sure to unselect ‘Respect double quotes(“) as a text delimiter’.

Finally, click ‘Next’.

In the Destination section, choose ‘Subscriber List’. Then, click on the folder named ‘my subscribers’ and select ‘All Subscribers’. Finally, click ‘Next’.

In the Mapping section, select ‘Add and Update’ and click ‘Next’.

In the Review section, check the input data and click ‘Finish’.

After completing the previous steps, you can schedule this automation to run every hour. This ensures that the data in Marketing Cloud is continuously updated with Sales Cloud.

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

Update All Subscribers — Salesforce Marketing Cloud Data Sync with Sales Cloud was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Salesforce Marketing Cloud is greatly dependent on the user database that the business keeps in their Sales Cloud setup. Having data inconsistencies affects communication with customers and muddles the view of an active audience.

When updated data about Subscribers and their status is exported from Salesforce Sales Cloud to the Marketing Cloud data extension, we often want to track the number and identity of Subscribers that have been updated successfully. Having a list of the Subscribers that have encountered an issue in the process, such as having an invalid email address, significantly advances data accuracy. To achieve this, we need to follow these steps:

1. Create Data Extension
2. Create Custom List Detective
3. Automation: Get subscribers from CRM
4. Automation: ExportAllSubscribers
5. Automation: Send List Detective report

To get started, we also need to create an FTP Account (File Transfer Protocol account) for transferring files with a host computer using FTP services, which we will use in the Automation process. To do this, go to Setup > Administration > Data Management > FTP Accounts. Then, in FTP Accounts, click on ‘Create User.

Important! By default, the report does not include the fields ‘Email Address’ and ‘Subscriber Key.’ To make these fields appear, we must file a support case requesting their addition.

Create Data Extension

Let’s create a Data Extension with the necessary fields and name it ‘All Subscribers Data’. For example, we can create a Data Extension with three fields:

• Subscriber Key;
• Status (subscription status);
• Email Address (subscriber email).

The Data Extension must contain information about all subscribers from Sales Cloud. You can use the Query Activity in Automation to populate this Data Extension.

Create Custom List Detective

Let’s create a List with the name ‘List Detective’:

1. Click on ‘Subscribers’;
2. Choose ‘My Subscribers’;
3. Navigate to ‘My Lists’;
4. Click ‘Create’;
5. Select ‘Public’ to display the publication list in the subscription center;
6. Save your changes by clicking ‘Save’.

Now, we can see our created list with fields, like this:

Automation: Get subscribers from CRM

Navigate to Automation Studio in Journey Builder and create a new automation called ‘List Detective Report’.

Select the ‘Data Extract’ activity and drag it to the right on the Canvas.

After clicking ‘Create New Data Extract Activity’, click ‘Choose’ in Data Extract.

In the Properties section, enter ‘Get subscribers from CRM’ in the Name field. In the File Naming Pattern field, input the desired file name, for example, ‘NotSentEmail’. Then, select ‘Data Extension Extract’ as the Extract Type. Finally, click ‘Next’.

In the Configuration section, select ‘Has Column Headers’ and enter a ‘,’ (comma) in the Column Delimiter field. For the DECustomer Key, enter the External Key Data Extension we created earlier. Then, click ‘Next’.

In summary, check the input data and click ‘Finish’.

Automation: ExportAllSubscribers

Select the ‘File Transfer’ activity and drag it to the right on the Canvas.

After clicking ‘Create New File Transfer Activity,’ click ‘Choose’ in File Transfer.

In the Properties section, fill in the Name field with ‘Export All Subscribers’. Choose ‘Move a File From Safehouse’ as the File Action, then click ‘Next’.

In the Configuration section, enter ‘NotSentEmail’ in the File Naming Pattern field. In the Destination field, choose ‘ExactTarget Enhanced FTP’. Click ‘Next’.

In summary, check the input data and click ‘Finish’.

Automation: Send List Detective report

Select the ‘Import File’ activity and drag it to the right on the Canvas.

After clicking ‘Create New Import Definition’, click ‘Choose’ in the Import File.

In the Properties section, enter ‘Send List Detective report’ in the Name field. If you want to receive emails with this data in .txt format, select ‘Send notification email to:’ and provide your email address. Finally, click ‘Next’.

In the Import File section, select ‘ExactTarget Enhanced FTP’ as the File Location. Enter ‘NotSentEmail’ in the File Naming Pattern field. On the right-hand side, in the ‘Delimiter’ section, choose ‘Comma’. Make sure to unselect ‘Respect double quotes (“) as a text delimiter’. Finally, click ‘Next’.

In Destination select ‘Subscriber List’, click on the My Lists folder, and select ‘List Detective’. Click ‘Next’.

Select ‘Add and Update’ in Mapping and click ‘Next’.

In the Review section, check the input data and click ‘Finish’.

After completing the previous steps, you can schedule this automation to be executed every 24 hours, ensuring that the data is always updated with Sales Cloud.

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

List Detective Report for Subscribers Data Consistency — Salesforce Marketing Cloud Guide was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Seamless Salesforce Data Generation: A Journey Towards Realistic Field Values and Efficient Relationships

What would you do if you were asked to generate thousands of opportunities, with different opportunity teams, connected to different contacts & accounts, at different stages of pipeline, and to top that — with products and prices? What if the client asked you to avoid using “Lorem ipsum” or “Test Test” contacts and instead use real names and addresses from a specific list of companies? Maybe you were also asked to include numerous relationships, possibly more than just a few?

Given the challenging nature of this task and its specific requirements, I would like to share my experience in data generation for Salesforce to share my knowledge with you and make your journey much smoother. 🙂

By acknowledging the data model and utilizing SFDX scripts, bash scripts, and various services, together we’ll discover how to efficiently generate and deploy data while minimizing manual interventions. So, without further ado, let’s dive into the details.

You probably already know that you can use sfdx data commands to import data to Salesforce. It’s a powerful tool that is used exactly for data import. It’s easy to insert related data using the reference. But there are few limitations:

• You can only insert up to 200 records per file;
• You can’t include references to records that are already in the org. For example, you won’t be able to link an existing Standard Pricebook Id if you insert Pricebook Entry records.

I’ve been doing import & export operations for sample data using Workbench and Dataloader.io. Both are capable of data manipulation, but Dataloader.io has restrictions toward the maximum number of data to be processed, which is 10000 records/month for a free license. So I chose Workbench, but you may use other, better tools.

To generate records, I have utilized various services that offer flexibility in configuring different values. Among them is the Convertcsv web service, which initially appeared helpful. However, as I considered the process of linking related records, I found that Python would be a highly convenient option for data processing. The idea of performing fake data generation within the same environment seemed like a perfect solution to me.

My expertise in this programming language is somewhat limited, so I was a bit cautious about getting sucked into all the libraries and figuring out all the language-specific things, but after a few attempts I realized that my goals can be easily reached with help of ChatGPT. I found a library called Faker, which helped me create fake data in the quickest and simplest way. It made the entire process much more convenient because I could try various options and generally felt more confident about it.

To give you a little bit of insight, the following code can generate company names. We can use them to enter into the Account Name field.

from faker import Faker
accNames = [Faker().company() for _ in range(5)]
# Result: ['Davis-Davis', 'Johnson, Haas and Wagner', 'Thomas Group', 'Wilson-Lewis', 'Wade, Fuller and Anderson']

Faker allows us to generate different kinds of dummy data, like:

• company()
• url()
• phone_number()
• word()
• city(), street_address(), country()
• email()
• first_name(), last_name()
• date_of_birth()

Based on the example & methods above, you can see that I’ve played around and came up with a script that can generate a number of accounts, with some of the fields filled. You may need to include additional or other fields, but these were enough in my case.

import csv
from faker import Faker

fake = Faker()


# Number of Salesforce Accounts to generate
num_accounts = 2000
# CSV file where to output data
output_file = "salesforce_accounts.csv"

# Define field names for the CSV file
field_names = ["Name", "Phone", "Email", "BillingStreet", "BillingCity", "BillingState", "BillingPostalCode"]

# Generate Salesforce Accounts
accounts = []
for _ in range(num_accounts):
   account = {
       "Name": fake.company(),
       "Phone": fake.phone_number(),
       "Email": fake.email(),
       "BillingStreet": fake.street_address(),
       "BillingCity": fake.city(),
       "BillingState": fake.state(),
       "BillingPostalCode": fake.postcode(),
   }
   accounts.append(account)

# Save Salesforce Accounts to CSV file
with open(output_file, "w", newline="") as file:
   writer = csv.DictWriter(file, fieldnames=field_names)
   writer.writeheader()
   writer.writerows(accounts)

print(f"{num_accounts} Salesforce Accounts generated and saved to {output_file}.")

# Result:
# Name,Phone,Email,BillingStreet,BillingCity,BillingState,BillingPostalCode
# Stevenson LLC,(106)049-6070,fernandezshannon@example.org,73037 Owen Shoal Suite 720,Kingburgh,Nebraska,06298
# Sullivan Inc,3417264849,walshseth@example.net,789 Williams Dam,Torreshaven,Wisconsin,57778
#...

When it comes to records that do not have lookup relationships, managing them is quite easy, but if the records do have such relationships, you can create an extra Python service to handle this case.

We created the file NotLinkedContacts.csv using the same approach employed for Account generation, incorporating all necessary fields with representative sample data. AccountId is the only field that was left empty, so we can add Ids later.

After generating and importing the Account records, they now possess unique Ids within the system. To proceed, I had to export these records through Workbench, including their Id values, so that I could utilize them later in the creation of a file containing Contact records with the AccountId field filled in. I saved this file as AccountsWithIds.csv.

I have created the following script for linking the Contact records with Accounts:

import sys
import csv

input_file = sys.argv[1]
output_file = sys.argv[2]
object_type = sys.argv[3]

# Read the Accounts.csv file and get the Id values
account_ids = []
with open('AccountsWithIds.csv', 'r') as accounts_file:
   reader = csv.DictReader(accounts_file)
   for row in reader:
       account_ids.append(row['Id'])

# Update the input file with the Account Id values
with open(input_file, 'r') as input_csv:
   data = list(csv.DictReader(input_csv))
   fieldnames = ['FirstName', 'LastName', 'Email', 'Phone', 'Title', 'Fax', 'Birthdate', 'Department','MailingCountry', 'MailingStreet', 'MailingCity', 'MailingPostalCode', 'LeadSource', 'AccountId']


   for i, row in enumerate(data):
       # Cycle through the account_ids list
       row['AccountId'] = account_ids[i % len(account_ids)] 

# Write the updated data back to the output file
with open(output_file, 'w', newline='') as output_csv:
   writer = csv.DictWriter(output_csv, fieldnames=fieldnames)
   writer.writeheader()
   writer.writerows(data)

print("CSV file updated successfully.")

The linking process can be outlined as follows:

1. We are retrieving Ids of the accounts into array;
2. We are assigning the AccountId in a cyclic manner to Contacts that have been previously generated. This means that if there are more contacts than accounts, we cycle through them repeatedly, starting from the first account and continuing until all contacts have been assigned an AccountId;
3. We save this into a LinkedContacts.csv file.

The script uses arguments provided to it as input. This method allowed me to develop a generic approach for establishing relationships between records of different types. Below is an outline of how the script execution would proceed.

python3 <service_name>.py <input_name_not_linked>.csv <output_name_linked>.csv

Example:

python3 linkService.py NotLinkedContacts.csv LinkedContacts.csv

And now, when the Contacts are linked, you can use a tool of choice to deploy them to the org.

How Bash scripts might help?

As part of my project, deploying Products to the organization was essential for their use in Opportunity Line Items. For those familiar with Products, Pricebooks, and Opportunities, you may know that in order to utilize Products within an Opportunity, they must have at least one Pricebook Entry in the Standard Pricebook. This Standard Pricebook is automatically generated in the organization.

Currently, I haven’t found a standard or more efficient method to insert Products with prices into the Pricebook Entry of the Standard Pricebook. For my requirement of inserting only 20 products (along with other objects where the quantity was < 200), I followed the initial approach outlined in the article. It’s worth mentioning that the Python script would be quite similar in this scenario.

sfdx force:data:tree:import

The command above can deploy some sObject records directly by specifying the corresponding .json file. Alternatively, we can use a special plan containing a list of sObjects and their respective JSONs.

Plan example:

[
 {
   "sobject": "sobject_api_name",
   "saveRefs": true,
   "resolveRefs": true,
   "files": ["file_with_records.json"]
 },
…
]

The contents of the file_with_records.json will look like this:

{
 "records": [
   {
     "attributes": {
       "type": "sobject",
       "referenceId": "someReferenceName1" // e.g AccountRef, ContactRef…
     },
     field1_api: value1,
     field2_api: value2,
     …
   },
   {
     "attributes": {
       "type": "sobject",
       "referenceId": "someReferenceName2"
     },
     field1_api: value1,
     field2_api: value2,
     …
   },
…
  ]
}

And now, how to get the Id of the Standard Pricebook? A little bit of magic with the bash scripts and it’s all done!

So, I am going to add text placeholders in JSON files with records to replace them with bash:

PricebookEntries.template.json

{
 "records": [
   {
     "attributes": {
       "type": "PricebookEntry",
       "referenceId": "PBERef1"
     },
     "UnitPrice": 3000,
     "Product2Id": "@ProductReference1",
     "Pricebook2Id": "@StandardPricebookPlaceHolder",
     "IsActive": true
   },
…
  ]
}

This is a .template file that has a placeholder for StandardPricebook (@StandardPricebookPlaceholder) which will be substituted with the actual value from the org using bash scripts.

Salesforce CLI provides the possibility to query data from the org using the terminal by sfdx data:query -q <soql_query>. By using such functionality, I was able to get Standard Pricebook Id.

STANDARD_PRICEBOOK_ID="$(sfdx data:query -q "SELECT Id FROM Pricebook2 WHERE IsStandard=true LIMIT 1" -o $TargetOrg -r csv | grep 01)"

After obtaining the required Id, we utilized the sed command to replace the Id in the relevant locations. This command facilitates the replacement of a specific string with the desired value, and we saved the updated results as a separate PricebookEntries.json file.

sed "s/@StandardPricebookPlaceHolder/${STANDARD_PRICEBOOK_ID}/g" ./data/PricebookEntries.template.json > ./data/PricebookEntries.json

The state of PricebookEntries.json:

{
 "records": [
   {
     "attributes": {
       "type": "PricebookEntry",
       "referenceId": "PBERef1"
     },
     "UnitPrice": 3000,
     "Product2Id": "@ProductReference1",
     "Pricebook2Id": "01s7R000006H1alQAC",
     "IsActive": true
   },
…
  ]
}

You can notice that the value in Pricebook2Id was replaced with the actual Id.

Finally, we can simply execute sfdx data:tree:import to deploy the needed records.

sfdx force:data:tree:import -p PlanForProducts.json -u $TargetOrg

Where PlanForProducts.json looks like:

[
 {
   "sobject": "Product2",
   "saveRefs": true,
   "resolveRefs": true,
   "files": ["Product2.json"]
 },
 {
   "sobject": "PricebookEntry",
   "saveRefs": true,
   "resolveRefs": true,
   "files": ["PricebookEntries.json"]
 }
]

The order of objects is very crucial in deployment as data:tree:import has the ability to link objects within one transaction.

When inserting a record of Product2, its ID is stored, allowing for future reference and linkage with other records. Here is an example of the records that are going to be inserted:

{
  "records": [
    {
      "attributes": {
        "type": "Product2",
        "referenceId": "PRODRef1"
      },
      "Name": "StellarGlo"
    },
    ...
  ]
}

By utilizing ProductReference1 in lookup fields, records will be immediately linked, just as it was done for PricebookEntries.json before.

…
   {
     "UnitPrice": 3000,
     "Product2Id": "@ProductReference1",
     "Pricebook2Id": "01s7R000006H1alQAC",
     "IsActive": true
   },
…

I applied a similar approach to insert Users, connecting them to existing Roles and Profiles. In the .json file that contains Users, I deliberately left placeholders, which were later replaced with the correct values obtained through the sfdx data:query command, assisted by sed.

Conclusion

In summary, the journey of generating and managing Salesforce sample data has provided immense value. By creating 5000 Leads, 2000 Accounts, 2000 Contacts, and 4000 Opportunities, we formed a comprehensive and interconnected dataset. This valuable information allows for a better understanding of customers, prospects, and their interactions. Moreover, by linking Opportunity Line Items and Opportunity Team Members, the collaboration improved, resulting in increased sales productivity. These efforts underscore the importance of effective data management in making informed decisions, targeted marketing, and efficient sales operations.

Using the approaches mentioned earlier saved me a lot of time and made it much easier to create and manage fake data, including modifying records. These services simplified the process and were especially useful when dealing with small chunks of data that needed to be linked together. sfdx force:data:tree:import was particularly helpful in these scenarios.

HINT: For the LeadSource field or picklist fields you can use the following function:

random.choice(stringArr['opt1','opt2'...])

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

Seamless Salesforce Data Generation: A Journey Towards Realistic Field Values and Efficient… was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Salesforce Summer 2020 release sprouted a lot of reviews and questions. But we wanted to give you more practical feedback about the newly introduced features, the experience we had on projects before they were introduced, what they could be useful for, and any limitations we see about these features. After all, Noltic is a 100% Salesforce solution vendor, so we know a thing or two about the platform.

Ready? Let’s go!

Introducing Dynamic Forms

This is probably the best feature Salesforce introduced in the Summer ’20 release, and that’s why it’s number one on our list. This was actually requested a few times by our customers, so yay.

Previously, to accomplish this, we had to build custom components and use fieldsets to allow customers to dynamically select fields that would appear on different parts of the page, as opposed to a monolithic block of fields in one place.

Another cool thing is that you can now leverage visibility rules to show and/or hide sections and fields. With this step, Salesforce has really outdone itself in terms of bringing flexible no-code solutions to its clients.

Unfortunately, we can’t use custom dynamic forms in development, so the feature is useful for administrators only.

Click here to learn more about this update.

Lightning Message Service Integration

Lightning Message Service (LMS) is a library that improves communication between UI components. The main problem LMS solves is various approaches to publishing and receiving messages across the Visualforce, Aura, and LWC components.

The components of the library include:

• Message Channel. The main component that enables messaging via LMS. To address it, code @salesforce/messageChannel in LWC, $MessageChannel global variable in Visualforce components, and lightning:messageChannel in Aura components.
• Scope. Defines the context for publishing, i.e., which subscriber components will receive messages. There are two scopes: active (default) and application. The active scope includes subscribers only from the active area of the application. The application or global scope ensures that all subscribers get the message, even if that application area is inactive.
• Publish. A method to send messages through a message channel.
• Subscribe. A method to receive messages from a message channel.

LMS makes communication across different components flexible and straightforward. Plus, it’s easier to develop and maintain connected components.

Click here to learn more about this update.

CSS Style Sharing within Lightning Web Components

With this release, you can also share CSS styles within Lightning Web Components. Now, it’s easier than ever to share code as well as styles and extend the styles of basic components in just a few clicks. This feature will come especially in handy when working with sets of extendable components.

You can also achieve a similar result using SCSS in LWC. It features a slightly different syntax, though, since you need to reference the file instead of the component itself.

Click here to learn more about this update.

Status Inquiry for Asynchronous Platform Event Publish Operations (Pilot Feature)

Now you can track the status of the logic executed under platform events using the publish status events. This feature is especially useful when you need to get the results after publishing events, regardless of their occurrence.

Imagine you need to run some synchronization with platform events and send some payload inside. Sometimes, the sync may fail due to various reasons, like the lack of the necessary data, bad data updating conditions, etc. Currently, we can only identify whether events were published or not, but receive no information about the logic execution inside platform event triggers, so publishers can’t determine if it was successful or not.

To make sending the execution status possible, you can create a separate platform event and error handling logic. This new feature will make everything available out of the box, eliminating the need for custom status notification mechanisms. This will also reduce the amount of work necessary for building these notifying mechanisms.

Unfortunately, it’s a pilot feature, so you can’t request it now. So it’s hard to tell how it will respond to different error types, retries, etc.

Click here to learn more about this update.

Removing Lightning Components from Managed Packages

As the Salesforce platform improves, some components get removed, deprecated, or replaced with newer and better ones.

Up until now, there was no way to delete LWC & Lightning components from a managed package. With this new feature, Salesforce ISV partners can improve their products by removing the components that are no longer necessary.

Click here to learn more about this update.

SFDX (Second-Generation Packages)

It looks like Salesforce is betting on second-generation packages, with quite a few features released to help with their development as well as converting first-generation packages to second-generation. These are the features we’re talking about:

• Package code coverage enforcement
• An early look at converting first-generation managed packages (Developer Preview)
• Org-Dependent unlocked packages
• Upgrades to unlocked and second-generation managed packages (Beta)

Click here to learn more about this update.

Aura Components in the ui Namespace to Be Deprecated

Starting from May 1, 2021, Salesforce will stop supporting Aura components in the ui namespace. So, if you’re still using them, consider looking at the component in the lightning namespace or writing custom ones.

Click here to learn more about this update.

User Permissions for Lightning Web Components

Salesforce has a flexible permission system. There are two types of permissions: system and custom permissions, which are stored in Profile and Permission Sets. Checking those permissions has become truly effortless.

Look at this code sample. It’s as easy as importing a static reference.

import hasPermission from '@salesforce/userPermission/PermissionName';

Now, imagine you want to know if a user has permission to see an expense report. The following code snippets are succinct and sufficient.

//ExpenseReport.js

import { LightningElement } from 'lwc';

import hasViewReport from '@salesforce/customPermission/acme__ViewReport';

export default class App extends LightingElement {

    get isReportVisible() {

        return hasViewReport;

    }

}

//ExpenseReport.html

<template if:true={isReportVisible}>

Click here to learn more about this update.

It might be hard to keep track of all the innovations SFDC is rolling out, so keep that ear to the ground! We hope the comments Noltic’s experts gave on the eight updates of the summer ’20 release were as useful for you as they were exciting for us. And if you liked them, check out other articles in Noltic’s blog. Stay tuned!

Originally published at https://noltic.com/ on September 8, 2020.

Salesforce ’20 Release: LMS, Dynamic Forms, User Permissions and more was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.

Originally published on July 31, 2020. Updated on June 19, 2023

For a business, phone numbers are usually the primary contact information of their customers and the key to long-running relations. The ability to collect valid phone numbers and operate them in accordance with their type, region or time zone can hugely decrease the time for business owners to close a deal.

For businesses running on Salesforce, there haven’t been any native solutions to effectively validate phone numbers, check them against proper length, format and country code.

One of our clients was looking for a solution compatible with their technology stack, and since there was no alternative, we put together our own ready-to-use product — CheckMyNumber. We originally released it on AppExchange under the name Libphonenumber, proudly becoming the trailblazers in the field of phone number formatting and validation.

Features & functionality

• Parsing, formatting, and validating phone numbers for all countries/regions of the world.
• Recognition of the phone number type with the ability to distinguish Fixed-line, Mobile, Toll-free, Premium Rate, Shared Cost, VoIP, Personal Numbers, UAN, Pager, and Voicemail (whenever feasible)
• Providing a confidence level on whether two numbers could be the same.
• Providing valid sample numbers for all countries/regions with the option to specify which type of sample phone number is needed.
• Quick estimation/guess of a phone number validity by its length only, much faster than a full validation.
• Full validation of a phone number for a region using length and prefix information.
• Phone numbers formatting on-the-fly when users enter each digit.
• Finding phone numbers within text.
• Providing the original carrier, timezone and location data related to a phone number.

“With the ability to format, validate and parse phone numbers directly in their Salesforce instances, our customers are instantly receiving reliable data without much effort to stay in direct contact with their client base. And that’s exactly what we wanted to deliver through our solution”, says Vladyslav Petrovych, CTO at Noltic

We regularly update our app with the latest phone metadata, bug fixes, and other improvements per client requests. Among the latest updates are some automated and declarative features. It made our app even more accessible as a no-code solution and decreased the time needed for adoption. This way we satisfy even more Salesforce users who are looking for a quick and dependable solution for their needs.

Start using CheckMyNumber with a free 14-day trial.

Read our other Medium posts and follow Noltic on LinkedIn, Facebook, and Twitter to stay updated about our news.

Noltic has created the library for parsing and validating international phone numbers in Salesforce was originally published in Noltic on Medium, where people are continuing the conversation by highlighting and responding to this story.