Forcetalks

Tag: Validations Rules

  • Custom Metadata Types: Your Recipe for API Key Security

    Custom Metadata Types: Your Recipe for API Key Security

    Imagine we are running a top-secret sandwich joint, and we’ve got the most delicious secret sauce recipe that’s known to humankind. Now, we don’t want to share our secret with anyone, but insiders should know the secret ! In this world of our Salesforce development, our secret sauce is the API key and endpoint URL we need for secure API integration. But worry not; we’ve got a clever trick for us: Custom Metadata Types!

    The Problem: Hardcoding Secrets

    While coding we shouldn’t hardcode our API key and endpoint URL. It’s like leaking out our secret sauce recipe on the internet. It’s not only insecure but also a recipe for disaster. People can misuse our API key and cause havoc.

    The Solution: Custom Metadata Types

    Here comes our savior, Custom Metadata Types. They work like our Salesforce Objects, and we can create records to store our API key and endpoint URL. It’s a good way right, to store our sneaky API keys!

    How to Use Custom Metadata Types:

    Step 1: Create Your Custom Metadata Type

    In setup < Custom Code < Custom Metadata Types < New

    Give it a label, say “API Config” and save. It will be saved as API_Config__mdt.

    dont miss out iconDon’t forget to check out: What is Custom Metadata in Salesforce in 2023?

    Step 2: Create Fields

    In our Custom Metadata Type, let’s add fields for our API key and endpoint URL. Let’s call them “API_Key__c” and “API_Endpoint__c.”

    Step 3: Create a Record

    Now, create a record with your API key and endpoint values. This record is like the key to our secret sauce vault. Store API Key and endpoint URL in this record. (You can name it according to you)

    Step 4: Retrieve Your Secrets

    Now in our Apex code, let’s retrieve the values from our Custom Metadata Type. No more hardcoded secrets in your code; it’s like magic!

    Add the below code to your Apex Controller and continue the rest of the coding.

    API_Config__mdt config = [SELECT API_Key__c, API_Endpoint__c FROM API_Config__mdt LIMIT 1];

String apiKey = config.API_Key__c;

String endpoint = config.API_Endpoint__c;

    Step 5: Enjoy our Secure Integration

    Hurray!!! We can now securely perform integration now.

    Why Custom Metadata Types?

    Security: Our secrets are locked up tight in Salesforce, away from prying eyes.

    Flexibility: We can easily update your secrets without changing your code.

    Control: We decide who gets access to your secret sauce vault.

    Questions for You:

    1. What’s your favorite secret sauce (or API integration)?
    2. Have you ever had an “API key exposed” nightmare?
    3. Did Custom Metadata Types make your life as a developer easier and more secure?

    dont miss out iconCheck out another amazing blog by Nayan here: Fetching and Displaying Data in Salesforce Lightning Web Components: A Step-by-Step Guide Salesforce

  • What is the Apex Metadata API? | All You Need to Know

    What is the Apex Metadata API? | All You Need to Know

    Let’s say that you support multiple orgs, and you’ve created a custom field. You want to add your new field to the page layouts in all your orgs. This type of configuration information is stored in metadata types and components in your org. 

    You can create a script that uses Apex Metadata API to add your new field to the page layouts in all your orgs directly from Apex. The metadata in the orgs is updated behind the scenes, so that your admins don’t have to make manual changes in each org. 

    Apex Metadata API also enables you to build custom setup experiences for your features. For example, let’s say you’ve created custom metadata types to support a new feature. The records of your custom metadata types must be configured differently for different countries. You can use Apex Metadata API to build a setup wizard that guides admins through a series of steps to configure the records. This automation saves your admins from having to make manual changes in the Setup UI. 

    Work with Metadata Directly from Apex 

    To work with metadata from within Apex code, use classes in the Metadata namespace. You can access two top-level metadata types: page layouts and records of custom metadata types, which gives you the ability to handle much of the customization and configuration for your org. 

    So, what kinds of things can you do with the Apex Metadata API? You can retrieve metadata from an org synchronously. Then you can inspect this metadata and update it, and you can also create metadata. It’s easy to deploy your updated metadata to your orgs, using asynchronous deployment. To be notified when your deployment completes, you can implement a callback. 

    dont miss out iconDon’t forget to check out: How to Update the Values of a Custom Picklist Field using Metadata API?

    We can deploy this new record to an org directly from Apex 

    Metadata.CustomMetadata customMetadata = new Metadata.CustomMetadata(); 
customMetadata.fullName = 'MyNamespace__MetadataTypeName.MetadataRecordName'; 
Metadata.CustomMetadataValue customField = new Metadata.CustomMetadataValue(); 
customField.field = 'customField__c'; 
customField.value = 'New value'; 
customMetadata.values.add(customField);

    Although there’s a lot you can do with Apex Metadata API, there are some limitations to keep in mind. 

    • In the current release, we support only two metadata types: page layouts and the records of custom metadata types. 
    • Reading, creating, and updating metadata are supported, but deleting metadata is not supported. 
    • We don’t have an API that lets you track the status of a deployment. However, you can set up a callback that is called when the deployment completes. 

    What About Security? 

    Metadata is powerful stuff. So, perhaps you’re concerned about security. Don’t worry! Trust is our number one value at Salesforce, and Apex Metadata API is built to be a trusted interface. Installed packages must be Apex-certified, or the subscriber org must turn on a setting to allow an Apex metadata deployment. You can track the namespace that initiated deployment in the Setup audit trail. 

    dont miss out iconCheck out another amazing blog by Rupesh here: What is the Apex Testing Framework in Salesforce in 2023?

    A Note for ISVs 

    Although the examples in this module focus on enterprises, Apex Metadata API can also be useful if you’re a developer at an ISV. Creating setup UIs specific to your apps and automating configuration changes can provide a boost to your business. With Apex Metadata API you can: 

    • Save money for you and your customers by making the setup experience faster and easier for non-experts. 
    • Eliminate some setup steps entirely by automating them. 
    • Provide admins the capability to change configuration on the fly by giving them a tool they can use without professional services expertise. 
    • Increase product adoption by lowering the barrier for customers to try your app. 
    • Protect your intellectual property. The ability to update protected metadata in your app means you can hide more of your configuration from customers. 
    • Eliminate reliance on remote site settings, reducing the complexity of your code and simplifying customers’ setup. 
  • How to Update the Values of a Custom Picklist Field using Metadata API?

    How to Update the Values of a Custom Picklist Field using Metadata API?

    The user can easily add, delete, or update the values of a custom picklist field manually. But there are times when you have to update and add the values of the custom picklist field by using code. That’s when metadata API comes to the rescue. For understanding metadata API, you can visit – Metadata, Custom Metadata Types, and Metadata API.

    Now, for updating the values of the custom picklist field there are two classes required:

    1. MetadataService.cls: You can find this class available on the internet as well but there are modifications done according to this scenario in this class. 
    1. We need to create another class for updating the values of a custom picklist field. The class we are calling here is updatingCustomPicklistValues. For this, we need a custom Picklist field on any object. 

    Here, the object we have taken is Opportunity and we have a custom picklist field named Picklist_check 

    dont miss out iconDon’t forget to check out: Visualizing Salesforce Metadata: Understanding the Relationships with AbstraLinx ERDs

    Updating Custom Picklist Values 

    public class UpdatingCustomPicklistValues { 
// Method to update the values of custom picklist field 
     public static void updatePicklistValues() { 
          MetadataService.MetadataPort service = new MetadataService.MetadataPort(); 
          service.SessionHeader = new MetadataService.SessionHeader_element(); 
          service.SessionHeader.sessionId = UserInfo.getSessionId(); 
          MetadataService.ValueSet picklistValueSet = new MetadataService.ValueSet(); 
          MetadataService.ValueSetValuesDefinition valueDefinition = new MetadataService.ValueSetValuesDefinition(); 
          List<MetadataService.ExtendedCustomValue> values = new List<MetadataService.ExtendedCustomValue>(); 
          // Fetching the values already available in the custom picklist field and storing them in the list 
          List<Schema.PicklistEntry> picklistValues = Opportunity.Picklist_check__c.getDescribe().getPicklistValues();
          // Adding the already available values 
               for(Schema.PicklistEntry picklistValue : picklistValues) { 
                    MetadataService.ExtendedCustomValue customValue1 = new MetadataService.ExtendedCustomValue(); 
                    customValue1.fullname = (string)picklistValue.getValue(); 
                    customValue1.default_x = false; 
                    customValue1.isActive = true; 
                    customValue1.label = picklistValue.getLabel(); 
                    values.add(customValue1); 
               } 
          //Adding the extra value, we want to add 
          MetadataService.ExtendedCustomValue customValue2 = new MetadataService.ExtendedCustomValue(); 
          customValue2.fullname = ‘1’; 
          customValue2.default_x = false; 
          customValue2.isActive = true;
          customValue2.label = ‘1’; 
          values.add(customValue2);
          valueDefinition.value = values; 
          valueDefinition.sorted = true; 
          picklistValueSet.valueSetDefinition = valueDefinition; 
          MetadataService.CustomField customField = new MetadataService.CustomField(); 
          customField.fullName = ' Opportunity.Picklist_check__c '; 
          customField.label = ' Picklist_check '; 
          customField.type_x = 'Picklist'; 
          customField.required = false; 
          customField.unique = false; 
          customField.valueSet = picklistValueSet;
          MetadataService.CustomField[] customFields = new List<MetadataService.CustomField> { customField }; 
          service.upsertMetadata(customFields); 
     } 
     // Method to save the work done 
     public static void handleSaveResults(MetadataService.SaveResult saveResult) 
          { 
          if(saveResult==null || saveResult.success) 
          return; 
          // Construct error message and throw an exception 
          if(saveResult.errors!=null) 
               {
                    List<String> messages = new List<String>(); 
                    messages.add( 
                    (saveResult.errors.size()==1 ? 'Error ' : 'Errors ') + 
                    'occured processing component ' + saveResult.fullName + '.'); 
                    for(MetadataService.Error error : saveResult.errors) 
                    messages.add( 
                    error.message + ' (' + error.statusCode + ').' + 
                    ( error.fields!=null && error.fields.size()>0 ? 
                    ' Fields ' + String.join(error.fields, ',') + '.' : '' ) ); 
                    if(messages.size()>0) 
                    throw new MetadataServiceExamplesException(String.join(messages, ' ')); 
               } 
          if (!saveResult.success) 
          throw new MetadataServiceExamplesException('Request failed with no specified error.'); 
     } 
     //Method to create an instance of MetadataService.MetadataPort 
     public static MetadataService.MetadataPort createService() 
     { 
          MetadataService.MetadataPort service = new MetadataService.MetadataPort(); 
          service.SessionHeader = new MetadataService.SessionHeader_element(); 
          service.SessionHeader.sessionId = UserInfo.getSessionId(); 
          return service; 
     } 
     public class MetadataServiceExamplesException extends Exception { } 
}

    dont miss out iconCheck out another amazing blog by Navdita here: What is the Grant Management System in Salesforce? | All You Need to Know

    Now , in the Developer console, save both classes. Then, click on Debug. Then, click Open Execute Anonymous Window. Copy and paste the following code in the anonymous window- 

    UpdatingCustomPicklistValues.UpdatePicklistValues();

    And Yaa, it’s done. 

  • What is Custom Metadata in Salesforce in 2023?

    What is Custom Metadata in Salesforce in 2023?

    Metadata is data that describes other data.  for instance, in Salesforce org, there’s a standard object called Account.  Once you add a record with a customer’s contact information to an Account, you add metadata and data.  

    What is a Custom Metadata Type?

    A custom metadata type is an object that’s used to define the structure for application metadata. The fields of custom metadata types, and therefore the values in the fields, consist only of metadata. The records of custom metadata types also are metadata, not data.

    When you deploy apps with custom metadata types, all of the records and fields are included within the package installation, so no additional steps are needed.  you’ll deploy custom metadata types from a sandbox with change sets or packaged in managed packages.

    dont miss out iconDon’t forget to check out: Visualizing Salesforce Metadata: Understanding the Relationships with AbstraLinx ERDs

    Use Cases for Custom Metadata Types

    1. Mappings: You can use custom metadata types to make associations between different objects, for instance, you’ll create a custom metadata type that assigns cities, states, or provinces to particular regions in a country.  
    2. Business rules: Salesforce has plenty of ways to define business rules.  A method is to combine configuration records with custom functionality, for instance, you’ll use custom metadata types along with some Apex code to route payments to the correct endpoint.  
    3. Master data: Say that your org uses a typical accounting app. You’ll create a custom metadata type that defines custom charges, like duties and VAT rates. If you include this sort as part of an extension package, subscriber orgs can reference this master data.  
    4.  Protected information: Store data like API keys during a protected package.  

    Custom Metadata supports most traditional filed types including the following 

    • Metadata Relationships  
    • Checkbox  
    • Date and Date/Time  
    • Email and Phone   
    • Number  
    • Percent  
    • Picklist  
    • Text and Text Area   
    • URL  

    Support To Developer  

    • Developers can use SOQL to read custom metadata types.  
    • To create or update metadata records, they will use the Metadata API.   
    • Apex code can create, read, and update (but not delete) custom metadata records.  

    Custom metadata types are often used directly from:  

    • Apex   
    • Flows   
    • Formula fields  
    • Process Builder  
    • Validation rules  

    dont miss out iconCheck out another amazing blog here: What are Aura Components in Salesforce? | The Ultimate Guide

    Conclusion  

    Custom metadata types are customizable, deployable, packageable, and upgradeable application metadata.  

    In many cases, custom metadata types have a plus over custom settings and custom objects.   

    They can make your application lifecycle management and compliance easier, faster, and more robust.