Create or Update Custom Metadata Type via Apex code – Salesforce Summer 17

Salesforce Summer 17 came with a most wanted feature for Custom Metadata Types which is managing it via Apex code. Now custom metadata records can be create and updated via Apex code which means no changes set or force.com migration tool is required from Summer 17.

There is a Namespace called Metadata introduced in Summer ’17 release to manage Custom Metadata.

Below is the sample code to create a Custom metadata type:-

First define a Metadata in org the same as previous releases. Here Response_Type__mdt is created.

Add new field Status_Code__c.

Here our purpose is to configure status codes by Custom Metadata proper message can be displayed.

New Metadata would look like as below:-

Custom Metadata

Few things to consider:-

• Custom Metadata create/update is asynchronous
• It actually does a deployment in backend instead of DML
• Doesn’t count against governor limit

Because the Custom Metadata update happens asynchronous it requires a way to get the status of deployment. So, it requires callback class. Lets define a callback class as:-

public class CustomMetadataCallback implements Metadata.DeployCallback {
    public void handleResult(Metadata.DeployResult result,
                             Metadata.DeployCallbackContext context) {
        if (result.status == Metadata.DeployStatus.Succeeded) {
            System.debug('success: '+ result);
        } else {
            // Deployment was not successful
            System.debug('fail: '+ result);
        }
    }
}

A callback class implement Metadata.DeployCallback interface.

Below is the way to create a custom Metadata:-

    // Set up custom metadata to be created in the subscriber org.
    Metadata.CustomMetadata customMetadata =  new Metadata.CustomMetadata();
    customMetadata.fullName = 'Response_Type.Not_Found_Code';
    customMetadata.label = 'Not_Found_Code';

    Metadata.CustomMetadataValue customField = new Metadata.CustomMetadataValue();
    customField.field = 'Status_Code__c';
    customField.value = '404';

    customMetadata.values.add(customField);

    Metadata.DeployContainer mdContainer = new Metadata.DeployContainer();
    mdContainer.addMetadata(customMetadata);

    // Setup deploy callback, MyDeployCallback implements
    // the Metadata.DeployCallback interface (code for
    // this class not shown in this example)
    CustomMetadataCallback callback = new CustomMetadataCallback();

    // Enqueue custom metadata deployment
    // jobId is the deployment ID
    Id jobId = Metadata.Operations.enqueueDeployment(mdContainer, callback);

By executing the above code we can create a Custom Metadata record in Response_Type__mdt custom Metadata.

All failures and success can be traced in callback class CustomMetadataCallback‘s method handleResult.

In addition deployment result can be checked in Setup -> Deploy | Deployment Status as shown below:

This is how we an create Custom Metadata record. It has been the most demanded feature since Custom Metadata introduced. Hope that will help a lot in Custom Metadata based implementations.

Useful links:-

Salesforce Summer ’17 release notes

Metadata Namespace reference

Stackexchange question on Custom metadata creation

Advertisement

Force.com Tooling API : Create Apex class, Apex Trigger dynamically and update/delete Apex Trigger, Apex class using Tooling API with REST API

In summer ’13 salesforce introduced a new set of API to control organization object like Apex class, Apex Trigger, TraceFlag, Visualforce Pages and other components from outside the organization. Tooling API allows to access coverage for Apex class and Apex trigger. Managing custom objects and anonymous execution of code and access debug logs from organization. Tooling API provides bothREST and SOAP API interface to access its features. Tooling API provides set of objects accessible from RESP API and SOAP API. It is just like SOAP API and REST API with a difference of endpoint only and selected set of objects available through it.Below is given Apex code example to create, update and delete operation on apex class. Which will answer, How to use  Tooling API? How to create Apex Trigger/Apex Class using Tooling API and How to update these? and various other useful features.

Before working with Tooling API object first create some generic methods which will used throughout the class e.g creating a http request.

public with sharing class SalesforceTool
{
    final String endpoint = 'https://na1.salesforce.com/services/data/v28.0/tooling/sobjects';

    // SomeValues to be store
    public String oid ;
    public String cid ;
    public String apmid ;
    public String carid ;

    public SalesforceTool()
    {
    }

    // used receive response by sending a http request
    private String getResponse(HttpRequest req)
    {
        try
        {
            Http httpreq = new Http();
            HttpResponse res = httpreq.send(req);
            String reqresponse = res.getBody();
            return reqresponse;
        }
        catch (Exception e)
        {
          return 'Error:' +e.getMessage();
        }
    }

    // create a http request with required endpoint and request method
    private HttpRequest createHttpRequest(String endpoint, String method)
    {
        HttpRequest req = new
        HttpRequest();
        endpoint += '';
        req.setHeader('Authorization', 'Bearer ' + UserInfo.getSessionID());
        req.setHeader('Content-Type', 'application/json');
        req.setEndpoint(endpoint);
        req.setMethod(method);
        return req;
    }
}

Here we created to methods to send request and receive response from Tooling API.

Endpoint url configuration of Tooling API is “http://domain/services/data/vXX.X/tooling/ where domain is a Salesforce instance or a custom domain and vXX.X is the API version number. For  example: http://na1.salesforce.com/services/data/v28.0/tooling/” as written in Salesforce Tooling API guide. In  endpoint “na1” is instance of salesforce which is dynamic so it should be take care that instance should match with organization instance. Organization instance can be get when authorization process is done, in which “session id”/”access token” received with Salesforce instance and time period.

In below example “UserInfo.getSessionId()” will be used to remove confusion and maintain code simplicity.

Create a new Apex Class:

public void createApexClass()
{
    // create a Http request with post method
    HttpRequest req = createHttpRequest(endpoint+'/ApexClass','POST');
    req.setBody( '{"Name":"NewApexClass1","Body":"public class NewApexClass1 {}"}');
    // send request and receive response
    String response = getResponse(req);
    // These two lines have no role in creating apex class. So they can be ignored for now.
    Map<String,Object> rmp = (Map<String,Object>)JSON.deserializeuntyped(response);
    oid = (String)rmp.get('id');
}

New Class Created Using Tooling API

In endpoint url “ApexClass” is added because we are working on ApexClass object to create a new class. By executing method a new Apex class named “NewApexClass1” will be created in organization and response will be like  {“id”:”01p900000039N0vAAE”,”success”:true,”errors”:[]} where in json id is “NewApexClass1” id so that we can perform other operation targeting this id.

Deleting an Apex Class:

// [Status=No Content, StatusCode=204]
public void deleteApexClass()
{
    HttpRequest req = createHttpRequest(endpoint+'/ApexClass/'+oid,'DELETE');
    String responseJson = getResponse(req); // Store the result to do something
}

To delete a apex class or some other component only DELETE request is need to do by passing component object’s id. If request is successful then Status code 204 will be received and Apex class will be deleted from organization.

Query Tooling Objects:

This will result a JSON of Apex class named “NewApexClass1” with id and name and some other details. There are two fields in JSON because query was about two fields only.

Response will be like:

{
    "size":1,"totalSize":1,"done":true,"records":[{
        "attributes":{
            "type":"ApexClass","url":"/services/data/v28.0/tooling/sobjects/ApexClass/01p900000039N0vAAE"
        }
        ,"Id":"01p900000039N0vAAE","Name":"NewApexClass1"
    }
    ],"queryLocator":null,"entityTypeName":"ApexClass"
}

Describing an individual Tooling object record:

public void accessApexClass()
{
    HttpRequest req = createHttpRequest(endpoint+'/sobjects/ApexClass/'+oid,'GET');
    getResponse(req));
}

This will result full metadata of Apex class in json format which id (oid) is passed with endpoint url.

Update a Apex class:

To update a apex class involves some more steps then steps we required above. Apex class can be update by  ApexClassMember Object and by same way ApexTrigger are updated by ApexTriggerMember and so on.

Steps to update are:

– First we need to create MetadataContainer object ex:

public void createMetadataContainer()
{
    HttpRequest req = createHttpRequest(endpoint+'/sobjects/MetadataContainer','POST');
    req.setBody('{"Name":"ApexContainer"}');
    String response = getResponse(req);
    Map<String,Object> rmp = (Map<String,Object>)JSON.deserializeuntyped(response);
    String cid = (String)rmp.get('id'); // used to save containerId
}

Store the MetadaContainer id because it will be required in ApexClassMember which is used to hold ApexClassMember, ApexTriggerMember etc.

– After this we need to create ApexClassMember object if we want to update ApexClass. If we want to update Apex Trigger then we need to create ApexTriggerMember. Here is example to create Apex Class so ApexClassMember will be created by:

// mid: MetadaContainserId
// axid: apexclass Id
// classBody: Apex class body (updated)
public void createApexClassMember(String mid, String axid, String classBody)
{
    HttpRequest req = createHttpRequest(endpoint+'/sobjects/ApexClassMember','POST');
    req.setBody('{"MetadataContainerId" : "'+mid+'", "ContentEntityId" : "'+axid+'", "Body": "'+classbody+'"}');
    String response = getResponse(req);
    Map<String,Object> rmp = (Map<String,Object>)JSON.deserializeuntyped(response);
    String apmid = (String)rmp.get('id'); // Store ApexClassMember Id
}

ApexClassMember require 3 parameters, MetadatacontainerId, ApexClass id (which is created previously) as ContentEntityId and full body of class as string which is updated. Sending request by above code will provide newly created ApexClassMember Id. This should be store in some variable as it will require in next step. Till now this class is not updated.

To update a class ContainerAsyncRequest object is used. It compile and deploy the code and provide status of code. Is code deployed or has some problem and what is the problem. ContainerAsyncRequest object can be created by:

public void createContainerAsyncRequest(String mid)
{
    HttpRequest req = createHttpRequest(endpoint+'/sobjects/containerAsyncRequest','POST');
    req.setBody('{"MetadataContainerId" : "'+mid+'", "isCheckOnly": "false"}');
    String response = getResponse(req);
    Map<String,Object> rmp = (Map<String,Object>)JSON.deserializeuntyped(response);
    carid = (String)rmp.get('id');
}

It return the id by this status of deployed code can be checked as:

public void getContainerAsyncRequestStatus()
{
    HttpRequest req = createHttpRequest(endpoint+'/sobjects/containerAsyncRequest/'+carid,'GET');
    String responseJson = getResponse(req));
}

In response to this it provide updated class detail including error. If class deployed successfully error message is null.

{
    "attributes":{
        "type":"ContainerAsyncRequest",
        "url":"/services/data/v28.0/tooling/sobjects/ContainerAsyncRequest/1dr90000000EKSBAA4"
    }
    ,"Id":"1dr90000000EKSBAA4","IsDeleted":false,
"CreatedDate":"2013-09-08T14:32:30.000+0000","CreatedById":"00590000001CfQjAAK",
"LastModifiedDate":"2013-09-08T14:32:30.000+0000","LastModifiedById":"00590000001CfQjAAK",
"SystemModstamp":"2013-09-08T14:32:30.000+0000","MetadataContainerId":"1dc9000000009tXAAQ",
"MetadataContainerMemberId":null,"ErrorMsg":null,
"CompilerErrors":null,"IsRunTests":false,
"State":"Queued","IsCheckOnly":false
}

Same way ApexTrigger can be created using ApexTriggerMember.

Execute Anonymous:

Executing the Apex code
anonymously will available from API version 29.0 or later in Tooling
API sp calling it will result a error “requested resource doesn’t
exist”.

These are the some basic implementation of
Tooling API. Which may help in how Tooling api is used to create
objects.

There are still many things to explore about
tooling api so this post is not completed. In next few days there will
be sure new updates about tooling api.

Salesforce Lightning: Useful Javascript Tips to Develop Efficient Lightning Components

In previous article we discussed about useful tips and things to use while developing Lightning components. Since Lightning development requires Javascript knowledge to perform various tasks on client side, so lets discuss about some Javascript useful tips and tricks to use when using Javascript in Lightning controllers. This article would be useful for developers who are migrated form Visualforce to Lightning and got little chance to work on Javascript during development on Visualforce framework.

Javascript is a multi-paradigm and imperative functional language. It has behavior of functional programing language and concepts of object-oriented programing. It means that you can create first class objects in Javascript and later change is properties and state in run-time.

Above properties provide super powers to Javascript but can cause great issues if not implemented correctly. Below are few things which should be considered when using Javascript:-

1. Type conversion v/s Equality ( === vs == )

In Javascript we have ‘===’ equality comparison operation in addition to ‘==’. It is good practice to use ‘===’ instead of ‘==’. Because double equal comparison can cause weird behavior in programing because it convert the type of data if it is not equal to right hand side data type. And programmer can never figure about why the value is true? Some examples:-

Using the === operator

true === 1; //false
"10" === 10;  //false
1 === [1]; //false

Using the == operator

true == 1; //true
"10" == 10;  //true
1 == [1]; //true

2. Concept of “undefined”

Javascript has additional NULL type which is “undefined”. Developer must always handle “blank double quotes (”), null (there in no NULL in javascript) and “undefined”.

'' == undefined; //false
undefined == '' //true
var a; console.log(a===undefined); //true
var a; console.log(a===null); // false

Comparing null with undefined using double equal (==) always return true but what if you get blank value instead of null/undefined. It will again cause a unexpected behavior.

3. Floating point Precision

If there is need to calculating decimal, it must be used with function `toFixed()’ or `toPrecision()`. Reason:-

Look at following post on Stackexchange salesforce. Apex Division Losing Precision. This applies to Javascript as well. Lets take the following example:-

0.1 + 0.2 === 0.3 //#1 false

Because it is actually 0.30000000000000004. Not that `toPrecision` and `toFixed` return `String` not the number type.

4. Use for loop instead of for-in

for-in loop like below we do not have control over iteration and calculation behind. IT can eat more processing time depending on object type.

var total = 0;
var items = new Array(4);
for (var i in items) {  
    total += items[i];  
}

We can use the same in for loop in more optimized and controlled way:-

var total = 0;
var items = new Array(4);
for (var i = 0, len = items.length; i < len; i++) {  
    total += arrayNumbers[i];  
}

In above example we have defined and calculated length in for-loop itself which will result into faster execution. Below is JSPerf test of both where iteration done adding value 1000 times in Chrome.

5. Use Map() to avoid duplicates

Instead of writing own algorithm to avoid duplicates in Array/List. Use Map() function. It works same as Apex Map, key and value pair. Below is the example:-

var myMap = new Map();
myMap.set('a', 1);
myMap.set('b', 2);
myMap.set('c', 3);
myMap.set('d', 4); // will be overriden
myMap.set('d', 5); // duplicate
for (var [key, value] of myMap) {
  console.log(key, value);
}

//a 1
//b 2
//c 3
//d 5

Keeping above things while developing code we can avoid various issues in Javascript and make our code efficient when the code run on client-side. Lighting components have client side controllers so, Visualforce developers migrating to Lighting must understand best practices we should implement in code.

Useful links:-

1. Learn JS
2. Lightning Tips: Transition to Lightning Framework
3. Stay tuned on Salesforce Stackexchange

Lightning Framework: Transition your Salesforce implementation to Lightning Components Framework

Salesforce Lightning Component Framework is a recent framework launched by Salesforce. It is based on open-source Aura framework which is Javascript based.

Main advantages of Lightning framework is it is light weight, client-side, out of the box responsive and efficient. It is based on event-driven architecture where UI events are handled by Javascript handlers.

Now the question comes is how we can leverage its advantages and what are the things we must consider to move the implementation to Lightning frameworks. One of the major problem while moving to Lightning is we have already functional Visualforce pages and those are completely different in architecture than Lighting framework. So lets find out some important things we should consider when taking decision of moving to Lightning framework or developing a new Lightning component.

How to begin

The very obvious answer is Salesforce Trailhead. To start, the recommended Trailhead module is “Lightning Components Basics“. This will provide basic idea of developing application using Aura Lightning framework, its structure and essential code syntaxes.

This is Javascript so Client-Side

Lightning framework is based on open-source Aura framework which is Javascript based. Javascript code runs on client machine. It does not require server to perform operation until and unless we are doing some Ajax based call to fetch data. If there is Javascript is base it means only data we need from server in most of the cases, that’s all!

In Lightning component_name.js file is client-side and Apex controller is our Server.

Leveraging this capability, code developed in Javascript become highly efficient. And we can distribute various tasks between client machine and server. So, plan in way what operation we should perform by Server process which tasks should happen on client side. Generally, light weight task should happen on client-side. For example: If we need to add a few values and output the sum then we should perform that task in Lightning controller. And if we want to aggregate 1000 of values then it is better to perform it on Apex controller.

Note: Each call to apex class though component is Asynchronous. In other words, it follows callback mechanism.

It is Case-Sensitive

Apex is case-insensitive which gives us freedom to write code without taking care of alphabet case. Lighting controller have just opposite to it. It is case-sensitive. A variable defined with name “motorVehicle” is different from “MotorVehicle”. So, care should be taken while writing Lighting controller code.

Make sure we code considering The Locker Service

This is recently introduced security layer to prevent un-authenticated changes to Lightning component. Because Lightning design is component based and there can be multiple components from different vendors so, a security layer must be available so, components don’t hack into other components and inject code.

To prevent un-authenticated code injection, locker-service is introduced. It forces the Lightning component to work in its scope. Attempt to modify any element outside of component boundary will result into “Access Denied” exception.

Best way to avoid such issues is always use methods provided by Lighting framework api. There would be javascript experts who can create magic, but in Lighting, it is better to follow Lighting Framework provided methods.

Lightning application are set of multiple components and those components can interact with registered events and their handlers. Set of components create a Lightning application. We can say it like a Visualforce page created from several Visualforce components. But Lightning is client side where Visualforce is server side.

Understand the SLDS (Salesforce Lightning Design System) CSS

SLDS is a CSS library to help us getting consistent user interface same as Salesforce Lightning view. This recommended CSS to use when we are developing code in Salesforce even in case of Visualforce. It can be downloaded from SLDS website.

Note that Lightning components don’t need to import this CSS. It is available by default. Here is Trailhead module named “Lighting Design System” to understand of SLDS system.

SLDS is one of the way to convert the Visualforce page in SLDS look alike. Instead of inventing own CSS, use SLDS css. However, it is a huge challenge in converting Visualforce tags into SLDS compatible HTML elements specially, <apex:pageblock/> and <apex:PageBlockTable/>.

Unit Testing

Right now Salesforce has not given any standard tool to perform unit testing on client-side controllers. However, there is a built-in unit testing framework for Aura, the technology on which Lightning components are based but not exposed yet. So, we have to make sure that:-

Variables and methods are used is in same case as it was declared.

If there is unexpected condition don’t hesitate to throw errors using

throw Error(' Message');

Javascript has try-catch as well. Utilize then to log any activity which would be helpful for developer.

try {
    Block of code to try
}
catch(err) {
    Block of code to handle errors
}

It is asynchronous so make sure declared variables don’t go out of scope in code and result in undefined errors which are hard to debug.

The Deployment

Lighting components are saved in metadata folder named “Aura” which contain the component, controller, helper etc. Controller and helper are Javascript files having .js extension. We can retrieve or deploy Lightning components by defining AuraDefinitionBundle type and name of the component as member in package.xml.

“aura” folder contains all components which further sub-divided based on component name.

In summary, the basic need to get into Lightning development is understanding of Javascript concepts. It does not mean to be a Javascript expert as there are <aura/> tags to make lot of thing easy. In comparison to Visualforce tags those aura tags are straightforward. But because lighting components are quick responsive and asynchronous so, win over many limitations of Visualforce.

Resource for the new Lightning experience

1. Get started with: https://www.linkedin.com/pulse/lightning-experience-create-pixel-perfect-visualforce-ashwani-soni?trk=mp-reader-card

2. Design Guide: http://www.lightningdesignsystem.com

3. Lightning Experience FAQs: https://developer.salesforce.com/page/Lightning_Experience_FAQ

4. Twitter: @SalesforceUX Stay tuned!