[Deepak]

Go through this link:

https://help.salesforce.com/articleView?id=send_email_directly_from_crm_record.htm&type=5

[Deepak]

Create a trigger on that custom object on update. then query the master record using id that is common in both

[Deepak]

You can add, edit, or delete Apex using the Salesforce user interface only in a Developer Edition organization,a Salesforce Enterprise Edition trial organization, or sandbox organization not in production. You can make changes in classes in sandbox and deploy in production

[Deepak]

Please go through this link :

https://support.zoom.us/hc/en-us/articles/205703209-Salesforce-Integration

[Deepak]

Please go through this link :

https://help.salesforce.com/articleView?id=knowledge_setup_users.htm&type=5

[Deepak]

internal Salesforce users to access Knowledge from inside any App through the Knowledge Tab. This grants users the ability to search for relevant articles specific to any issue or query that they may be having. As you can see from the below screenshot you can see and filter various bits of information such as the category, sub category and status of the articles.

[Deepak]

Customizations are used when an admin needs to work with a small set of records or fields, or if he or she needs to link to an external server. S-Controls allow Salesforce developers to leverage HTML and Javascript to create custom pages and UI components.

[Deepak]

You want to get all matching record, you should use Fast Lookup. In the fast lookup it will show all the record with given prefix. record will return only first matching record. If you want to get all matching record, you should use Fast Lookup. In the fast lookup it will show all the record with given prefix.

[Deepak]

Reports are similar to summary reports but allow you to group and summarize data by both rows and columns.They can be used as the source report for dashboard components. Use this type for comparing related totals, especially if you have large amounts of data to summarize and you need to compare values in several different fields, or you want to look at data by date and by product, person, or geography. Matrix reports without at least one row and one column grouping show as summary reports on the report run page.
Watch Video Demo Building Matrix Reports. Reports are the simplest and fastest way to look at data. Similar to a spreadsheet, they consist simply of an ordered set of fields in columns, with each matching record listed in a row. Tabular reports are best for creating lists of records or a list with a single grand total. They can’t be used to create groups of data or charts, and can’t be used in dashboards unless rows are limited. It displays just the row of records in a table-like format with the grand total. That is why Tabular reports cannot be used for generating dashboards.

[Deepak]

If you're using a Visualforce email template, you define how you want your data to be formatted / displayed when you create the template.  To pass the objects to fill those fields, you use the "Recipient" and "RelatedTo" attributes when you call the template object from APEX.

[Deepak]

The Salesforce Help covers only the standard objects provided with the initial Salesforce integration. Custom related lists display on the lower portion of the detail page for another record. They list the custom object records that are associated with that record.

[Deepak]

Select sync direction and conflict behavior. Assign users and profiles to a configuration.

[Deepak]

To deploy it in production, a user with Author Apex permission must deploy the triggers and classes using deployment tools. However, Visualforce pages can be created and edited in both sandbox and in production. Only if the page has to do something unique (different values), it would have to be developed via Sandbox. Only Developer Edition, Sandbox, and Trial organizations have the ability to create, edit, and delete Apex classes and triggers directly in the Salesforce CRM user interface. Unlimited Edition and Enterprise Edition production organizations can execute Apex and can view Apex in the user interface, but modifying Apex in the user interface is not allowed.

[Deepak]

Inserting or updating records, the API accepts either the 15-character case-sensitive ID or the 18-character case-insensitive ID. When querying or searching records using the API, you must specify a value of “1” for the “useCaseSafeIDs” parameter to indicate that you want the API to return case-insensitive IDs. If you don’t specify the “useCaseSafeIDs” parameter, you automatically receive case-sensitive IDs. The API can return either a case-sensitive or a case-insensitive ID field value. The case-insensitive ID is identical to the 15-character case-sensitive ID, but with 3 extra characters appended to indicate the casing of each of the original 15 characters.

[Deepak]

Component Namespace
Every component is part of a namespace, which is used to group related components together. If your organization has a namespace prefix set, use that namespace to access your components. Otherwise, use the default namespace to access your components.
Another component or application can reference a component by adding <myNamespace:myComponent> in its markup. For example, the helloWorld component is in the docsample namespace. Another component can reference it by adding<docsample:helloWorld /> in its markup.

Lightning components that Salesforce provides are grouped into several namespaces, such as aura, ui, and force. Components from third-party managed packages have namespaces from the providing organizations.

In your organization, you can choose to set a namespace prefix. If you do, that namespace is used for all of your Lightning components. A namespace prefix is required if you plan to offer managed packages on the AppExchange.

If you haven’t set a namespace prefix for your organization, use the default namespace c when referencing components that you’ve created.

 

[Deepak]

In Lightning components, basically we can use CSS by 3 ways-:
Use Inline CSS.
By external CSS file.
By create style tab in component bundle.

[Deepak]

The tools included in lightning are:

Browser: Google Chrome
Browser Debugger: Chrome DevTools
DevTools Extension: Salesforce Lightning Inspector
Editor: Force.com IDE

[Deepak]

Components use @wire in their JavaScript class to specify a wire adaptor or an Apex method. To read Salesforce data, Lightning web components use a reactive wire service. When the wire service provisions data, the component rerenders. Wire Service is reactive. So, it works asynchronously. But the page renders based on the values retrieved. You cannot chain Wire Service methods. Use dynamic binding instead.LWC is only for Salesforce applications.

[Deepak]

Lightning Inter-Component Communication Patterns

If you’re comfortable with how a Lightning Component works and want to build production-grade applications for use in your org or to sell in AppExchange, this article is a must read. Understanding how a singular component works is important, but understanding how they work together is essential for building an effective application.

Interactive applications require components that can exchange data. In traditional HTML and JavaScript, this is straightforward as any script can modify the whole page. The modular nature of the Lightning Component Framework (LCF) requires more consideration for interactivity.

In line with best practices for security concerns, Lightning components are intentionally initially isolated from each other. By default, they’re safe from receiving or causing unwanted interference that can be exploited for malicious purposes. In practice, a Lightning component’s code cannot directly interact with its parent and vice versa. A parent component cannot manipulate its children or siblings as with standard JavaScript and the DOM. Inter-component communication must be specified by the developer.

In LCF, inter-component communication is supported in several well-defined ways. One can only use the following developer-defined interfaces to specify what can be exchanged:

Attributes or Methods to pass data down the component hierarchy
Lightning Events to pass data up and around in the component hierarchy
Passing data down the component hierarchy
Attributes
Attributes are the most commonly used element to pass data down the component hierarchy as they are simple to use. In order to pass data down from a parent component to its child, simply use the following code:

Parent component

1
<aura:component>
2
<aura:attribute name="parentAttribute" type="String"/>
3
<c:childComponent childAttribute="{!v.parentAttribute}"/>
4
</aura:component>
Child component

1
<aura:component>
2
<aura:attribute name="childAttribute" type="String"/>
3
</aura:component>
In this example, the parent component value of parentAttribute is transferred to the childAttribute of the child component via the {!v.parentAttribute} expression.

This is perfect if you just want to display the data in a child component. What about if you also want to execute some logic when the attribute’s value changes?

Consider the following updated definition of childComponent :

1
<aura:component>
2
<aura:attribute name="childAttribute" type="String"/>
3
<aura:handler name="change" value="{!v.childAttribute}" action="{!c.onChildAttributeChange}"/>
4
</aura:component>
With the addition of a change handler, the child component can now trigger the onChildAttributeChangecontroller function automatically when the value of childAttribute changes. This allows us to implement some custom logic such as:

1
({
2
onChildAttributeChange : function (component, event, helper) {
3
console.log("Old value: " + event.getParam("oldValue"));
4
console.log("Current value: " + event.getParam("value"));
5
}
6
})
We now have established a top-down communication chain between the parent and the child component. This can be summarized in these few steps:

parentAttribute value changes
parentAttribute value is transferred to childAttribute
childComponent’s change handler triggers the onChildAttributeChange controller function
This approach works great for processing an attribute. What about multiple attribute changes? If you want to change two or more attributes and then trigger some logic, this method becomes unwieldy. You can either combine the attributes into a larger object (not always practical) or write a complex synchronization algorithm (please don’t). Instead, I recommend methods for multiple attribute changes.

Methods
Based on frequent exchanges with the developer community, I have gathered that methods tend to be overlooked in favor of attributes. However, I have found methods to be quite flexible, as they allow users to create and expose component APIs.

Let’s look at an example involving two components communicating with a method. Here we have a child component that exposes a myMethod method with two parameters (param1 and param2).

1
<aura:component>
2
<aura:method name="myMethod" action="{!c.executeMyMethod}">
3
<aura:attribute name="param1" type="String"/>
4
<aura:attribute name="param2" type="String"/>
5
</aura:method>
6
</aura:component>
myMethod is hooked to an executeMyMethod function in the component’s controller:

1
({
2
executeMyMethod : function (component, event, helper) {
3
var params = event.getParam('arguments');
4
console.log('Param 1: '+ params.param1);
5
console.log('Param 2: '+ params.param2);
6
}
7
})
This function retrieves the arguments (param1 and param2) passed to myMethod and outputs them in the console. Note that the arguments key used in event.getParam is a constant.

Let’s now look at the parent component. It has two attributes (parentAttribute1 and parentAttribute2), a reference to the child component, and a button.

1
<aura:component>
2
<aura:attribute name="parentAttribute1" type="String" default="A"/>
3
<aura:attribute name="parentAttribute2" type="String" default="B"/>
4

5
<c:childComponent aura:id="child"/>
6

7
<lightning:button label="Call child method" onclick="{! c.onCallChildMethod }" />
8
</aura:component>
When clicked, the button calls a onCallChildMethod function in the component’s controller. This function retrieves the value of the two attributes and retrieves the child component by using its aura:id. It then calls a myMethod method on the child component and passes the two attribute values as parameters.

1
({
2
onCallChildMethod : function(component, event, helper) {
3
var attribute1 = component.get('v.parentAttribute1');
4
var attribute2 = component.get('v.parentAttribute2');
5
var childComponent = component.find('child');
6
childComponent.myMethod(attribute1, attribute2);
7
}
8
})
If we now step back and look at the big picture, here’s what happens:

When the parent component button is clicked, the onCallChildMethod controller function of parentComponent is called
onCallChildMethod retrieves a reference to childComponent using find with an aura:id
onCallChildMethod calls the myMethod method of childComponent
myMethod triggers the executeMyMethod controller function of childComponent
This “method” approach is quite powerful as users can pass data to a child component and perform some operations once this is done. Users can also create distinct methods involving the same arguments but triggering different functions. Finally, developers get the benefit of clarity by exposing named methods that—hopefully—reflect their intended behavior.
Achieving all of this is not possible by just passing attributes from parent to child components.

Passing data up and around the Lightning component hierarchy
The way to pass data up and around in the Lightning component hierarchy is to use events. There are two types of events that users can employ for that purpose: application events and component events.

There are some minor syntax differences between these two types of events, but we do not discuss them in this article for the sake of brevity. Instead, we focus on their propagation mechanisms, which in turn dictates their use cases.

Application Events
Application events are broadcast to all Lightning components that are registered as listeners for that specific event.

If we look at the example described in the schema on the right, here’s what happens:

A component fires an application event.
All other components can handle the event provided that they have registered the appropriate event handler.
All event handlers are triggered simultaneously. There is no way to cancel an application event once fired.

Application events are great for supporting business logic events as they are quite flexible: They do not impose a particular architecture. This is ideal when building components that are exposed in the Lightning App Builder. However, bear in mind that this flexibility comes at the expense of performance in certain use cases due to the event broadcast.

For example, it can be expensive to use an application event for a fine-grained component such as a button to notify other components that it is clicked. Your event will be sent to all of the components. They have to identify the source of the event then, verify if they handle it. Typically all components except one are registered to handle the event. Conversely, if you use an application event for a coarse-grained event in the App Builder that two other components may listen to, there is no performance impact.

Component Events
Component events are “clones” of standard DOM events (mouse clicks, key press, and so on). Just like their DOM counterparts, they propagate up in the component hierarchy via a bubbling mechanism and can be stopped en route to the application root component.

Here is an example of such a behavior:

Component E fires a component event.
Event bubbles to E’s direct parent: component D.
Component D can handle the event or not and optionally prevent its propagation by capturing it.
If Component D did not capture the event, it propagates to A (this applies even if D did not handle the event).
Component B and C do not handle the event, as they are not in the ancestry line of E.
The advantage of component events is that you know their maximum scope in advance (all parent components) and you have some degree of control over it (you can capture the event along the way).

Advanced event architecture
As a rule, consider using a component event before employing an application event. These are more common and usually have little effect on performance. However, when facing a blocking use case or an overly complex architecture, think about going for an application event.

Consider using a component event for handling low-level UI interactions such as selections and form validation. You can then combine these with application events that handle “business” events. This integrates into a larger architecture via a central “dispatcher” component such as this:

 

[Deepak]

Share a Report or Dashboard with a Group in Salesforce Classic
Enhanced folder sharing is the default option for all orgs created after the Summer ’13 Salesforce release. If you have orgs created before Summer ’13 and don’t want to reassign permissions for the legacy reports and dashboards, you can use legacy folder sharing in Salesforce Classic.

REQUIRED EDITIONS AND USER PERMISSIONS
Available in: Salesforce Classic (not available in all orgs)
Available in: Group, Professional, Enterprise, Performance, Unlimited, and Developer Editions
Available in: Legacy Folder Sharing

USER PERMISSIONS NEEDED
To share a report folder with public groups:
Run Reports AND Manage Dashboards OR Manage Reports in Public Folders
To share a dashboard folder with public groups:
Run Reports AND Manage Dashboards OR Manage Reports in Public Folders
On the Reports tab, hover over a report folder in the left pane, click  , and then select Share.
Select Public Groups.
Find the group you want, and click Share.To search, start typing a name.
Choose the sharing level you want to give this group.
NOTE Portal users can only have Viewer access to reports, and they can’t use dashboards.
Click Done, review your changes, and click Close.

[Deepak]

You cannot call another future method from a future method. As per Salesforce documentation,

You cannot call a method annotated with future from a method that also has the future annotation. Nor can you call a trigger from an annotated method that calls another annotated method.
If you do not have dependency between f1 & f2, you can call both methods one by one from original class.

You cannot normally call a future method in another future method, but if your salesforce license has the pilot feature enabled then you can call a future method from another future method.

To get the pilot feature you ll need to contact the salesforce where you can also double or triple some governor limits of asynchronous apex in your org.

[Deepak]

The Distinction: Data Privacy versus Protection
In a nutshell, data protection is about securing data against unauthorized access. Data privacy is about authorized access — who has it and who defines it. Another way to look at it is this: data protection is essentially a technical issue, whereas data privacy is a legal one.

These distinctions matter because they're woven deeply into the overarching issues of privacy and cybersecurity, both of which loom large in businesses, politics and culture. For industries subject to compliance standards, there are crucial legal implications associated with privacy laws. And ensuring data protection may not adhere to every required compliance standard.

When Words Matter
Just to make things more complicated, according to the Storage Networking Industry Association (SNIA), the laws and regulations that cover "the management of personal information" are typically grouped under "privacy policy" in the United States and under "protection policy" in the EU and elsewhere.

The European Union's General Data Protection Regulation (GDPR), a supervisory authority that will go into effect May 25, 2018, requires businesses to protect the "personal data and privacy of EU citizens for transactions that occur within the EU." However, the GDPR's data protection law has a much different view of personal identification information than the US. GDPR compliance requires that companies use the same level of data protection for cookies as they do for stored personally identifiable information, such as social security numbers.

Make sure you are compliant with the GDPR. Download this free guide.
Data Privacy and Security: One Doesn't Ensure the Other
What's important to understand when comparing data privacy vs. data protection is that you can't ensure data privacy unless the personal data is protected by technology. If someone can steal personal data, its privacy is not guaranteed, which puts you at risk for identity theft and other personal security breaches. But the opposite relationship isn't always true: personal data can be protected while still not being reliably private.

 

How? When you swipe your credit card for a service provider, you're doing two things. First of all, you're trusting the service provider and payment system with your personal data protection — to make sure, among other things, shady cybercriminals and other third parties can't access your credit information without your consent. But you're also trusting them to honor your data privacy by not misusing the information even though you provided it to them.

The point is technology alone cannot ensure the privacy of personal data. Most privacy protection protocols are still vulnerable to authorized individuals who might access the data. The burden on these authorized individuals is, above all, about privacy law, not technology.

[Deepak]

If the value of a reactive property changes, the component rerenders. A reactive property can be public or private. When a component rerenders, all the expressions used in the template are reevaluated.

Public Properties
To expose a public property, decorate it with @api. Public properties define the API for a component. An owner component that uses the component in its markup can access the component’s public properties. Public properties are reactive. If the value of a reactive property changes, the component rerenders. When a component rerenders, all the expressions used in the template are reevaluated.
Tracked Properties
To track a private property’s value and rerender a component when it changes, decorate the property with @track. Tracked properties are also called private reactive properties.
Reactive Property Data Types
There are some limitations on the depth of changes tracked for rerendering in reactive properties. The tracking depth depends on the type of the reactive property.
Boolean Properties
Boolean attributes on standard HTML Elements are set to true by adding the attribute to the element. The absence of the attribute defaults the attribute to false. Therefore, the default value of an attribute is always false. Lightning web components use the same principle for boolean properties.

[Deepak]

An inbound change set is a change set that has been sent from another Salesforce org to the org you are logged in to. A change set must be deployed for the changes to take effect. You can deploy the contents of an inbound change set as a whole but not on a component-by-component basis.

An outbound change set is a change set created in the Salesforce org in which you are logged in and that you want to send to another org. You typically use an outbound change set for customizations created and tested in a sandbox and that are then sent to a production org.

[Deepak]

Deployment Connections for Change Sets
A deployment connection is required between two Salesforce orgs to send change sets from one org to another. You can’t create deployment connections between arbitrary orgs. Instead, you create connections between all orgs affiliated with a production org. For example, if you have a production org and two sandboxes, a deployment connection is created between production and each sandbox. Also, a deployment connection is created between the two sandboxes.
Authorizing a Deployment Connection
Authorize inbound changes so that another Salesforce org can send change sets to the org you are logged into.
Viewing Available Deployment Connections
A deployment connection enables customizations to be copied from one Salesforce org to another. The deployment connections list shows which orgs are authorized to upload changes to this org, and which orgs allow this org to upload changes to them.
Viewing Details of a Deployment Connection
A deployment connection enables customizations to be copied from one Salesforce org to another. The deployment connections list shows which orgs are authorized to upload changes to this org, and which orgs allow this org to upload changes to them.