Tag: Salesforce

Promises with lightning web components, Explained!!!

The standard definition for promise says that Promise is the object which can produce some value in the future. These objects are used in asynchronus calls, where we can not predict time to complete the transaction. Promise helps to perform actions based on the results of the asynchronous calls.

Promises Terminology

  • Fulfilled – Indicates that the action has completed without errors
  • Rejected – Indicates that the action has failed with errors
  • Pending – Indicates that the action still is in flight

Let see the syntax below

Promise Declaration – The function declared below returns a promise. For the understanding, lets put a sample timeout in the function body. 

Function makeAsyncCall(msg){ 
return new Promise((resolve, reject) => {
      setTimeout(
        () => {
          console.log(msg);
          resolve();
        }, 
        1000);
    }) 
}

Promise Execution – While calling this function in the Javascript, we can call it using the below syntax. Then segment will execute when the promise is complete, and similarly catch function will execute in the action failure. 

            makeAsyncCall('msg')
            .then(result => {
                console.log('This promise is resolved')
            })
            .catch(error => {
                console.log('This promise has failed')
            });

This is so simple, but yet so powerful. Let’s see some benefits of using Promises

Chaining of Events 

            makeAsyncCall('msg')
            .then(result => {
                console.log('This promise is resolved')
                // Call a new promise in here
            })
            .catch(error => {
                console.log('This promise has failed')
            });

Then block refers to the successful action on the event, we can use the same block to call another promise function inside then block. Hence you can keep chain multiple actions using promises

Error Handling

As seen in the above example, we can associate catch block with a promise. Every time an action on a promise fails, execution goes the the catch block, and statements in the catch block are implemented. We usually use some error handling or showing error toast messages in the catch block

Salesforce – Lightning web components with Quick actions

Salesforce recently announced lightning web components to be GA feature. In a major effort to standardize the UI web developments, lightning web components (LWC)are a major foot forward. Interestingly, Salesforce is not moving away from the Aura framework, and lightning web components will coexist and interact with each other. To get a better understanding of this new programming model, we will try to create a quick action using LWC model

Entire code is available at this Github Location

Use Case – Create a quick action on the contact object, which will display sample contact fields values (name, email, phone, title).

Design – To demonstrate the working of this functionality, we will create a quick action. Quick action will call the lightning component. Lightning component will pass the record id of contact to the lightning web component. Finally Lightning web component will make standard call to fetch contact details.

  • Quick Action – To be created on Contact Object
  • Lightning Component (Aura) – Quick action will execute the this component, which in turn will call the lightning web component
  • Lightning Web Component

Quick Action

Quick Action configuration is standard and calls the lightning component.

Lightning Component 

<aura:component implements="force:lightningQuickActionWithoutHeader,force:hasRecordId" >
    <c:contactDetailsLWC recordId="{!v.recordId}"/>
</aura:component>

As you can see in the second line we are passing the record id to the Lightning web component

Lightning Web Component 

// ContactDetailsLWC.html
<template>
    <lightning-card
        title="Contact Information"
        icon-name="standard:contact"
    >
    <template if:true={contact.data}>
            <lightning-layout vertical-align="center">
                    <lightning-layout-item padding="around-small">
                            <p>Name : {name}</p>
                            <p>Account :{accountname}</p>
                            <p>Phone :{phone}</p>
                            <p>Email :{email}</p>
                        </lightning-layout-item>        
            </lightning-layout>
    </template>
</lightning-card>
</template>

//contactDetailsLWC.js
import { LightningElement,api, wire  } from 'lwc';
import { getRecord, getFieldValue } from 'lightning/uiRecordApi';
import NAME_FIELD from '@salesforce/schema/Contact.Name';
import TITLE_FIELD from '@salesforce/schema/Contact.Title';
import PHONE_FIELD from '@salesforce/schema/Contact.Phone';
import EMAIL_FIELD from '@salesforce/schema/Contact.Email';
import ACCOUNT_NAME_FIELD from '@salesforce/schema/Contact.Account.Name';

const fields = [NAME_FIELD, TITLE_FIELD, PHONE_FIELD, EMAIL_FIELD,ACCOUNT_NAME_FIELD];

export default class ContactDetailsLWC extends LightningElement {
    @api recordId;
    @api objectApiName = 'Contact';
    accountName = NAME_FIELD;
    @wire(getRecord, { recordId: '$recordId', fields })
    contact;

    get name() {
        return getFieldValue(this.contact.data, NAME_FIELD);
    }
    get accountname() {
        return getFieldValue(this.contact.data, ACCOUNT_NAME_FIELD);
    }
    get title() {
        return getFieldValue(this.contact.data, TITLE_FIELD);
    }
    get phone() {
        return getFieldValue(this.contact.data, PHONE_FIELD);
    }
    get email() {
        return getFieldValue(this.contact.data, EMAIL_FIELD);
    }
}

In the javascript file, recordId variable is declared as @api (public variable). This variable will receive record id from aura component and will use the @wire to fetch contact details. Finally, getter methods will retrieve field values from the contact variable.