Implement Drawing and Signature in Salesforce Lightning Web Components

While exploring HTML5 components and jQuery into Lightning Web Components I have plan in mind to have develop use case on drawing and specially to capture users signature functionality on any objects. As jQuery is still very popular Java Script library to support any web browser even in Mobile Apps, I have decide to do to support Salesforce desktop and mobile App Salesforce1 for Android and Apple.

1. Business requirement is to capture a Customer Digital Signature before Deal Opportunity.

2. Requirements is Customer to Scratch specific drawing according to Business needs.

Basics -

Before get start in depth coding lets have learn some basics -

I have used Signature Pad which is a jQuery plugin that takes advantage of HTML5 canvaselement and javascript to create a flexible and smooth Signature / Drawing Pad on your web page & app and we will building on Lightening Web Component.

<canvas class="pad" width={cWidth} height={cHeight}></canvas>

The HTML<canvas> tag is used to HTML5 draw graphics, on the fly, via scripting (usually JavaScript). However, the <canvas> element has no drawing abilities of its own (it is only a container for graphics) - you must use a script to actually draw the graphics.

The querySelector() method returns the first element that matches a specified CSS selector(s) in the document.

var $drawnCanvas = this.template.querySelector('canvas');

The renderedCallback() is unique to Lightning Web Components. Use it to perform logic after a component has finished the rendering phase. This hook flows from child to parent. When a component renders, the expressions used in the template are reevaluated.

Salesforce Lightning Web Component

Lightning web components are custom HTML elements built using HTML and modern JavaScript. Lightning web components and Aura components can coexist and interoperate on a page. To admins and end users, they both appear as Lightning components.

If you are good in web development but new in LWC please try in trailhead to Create a Hello World Lightning Web Component .

Now Let workout to the steps how we can develop smooth drawing or signature pad and save that drawing to specific record of an Object , here I have used Opportunity for my use cases.

Step: 1 - Create Lightning Web Component project as I named it 'drawingPadLWC' .

Step: 2 - Under project directory you will have drawingPadLWC.html  there will have some HTML code define UI elements in drawingPadLWC.html and drawingPadLWC.css defined drawing pad's cursor !

	<template>
	<form method="POST" action="">
	<div>
	<canvas class="pad" width={cWidth} height={cHeight}></canvas>
	</div>
	<div class="slds-float_right" style="padding-top:5px;">
	<lightning-button variant="destructive" label="Save" title="Save" onclick={saveDrawing} class="slds-m-left_x-small"></lightning-button>
	<span class="clearButton" style="padding-left:5px;">
	<lightning-button variant="destructive" label="Clear" title="Clear" class="clearButton"></lightning-button>
	</span>
	</div>
	</form>
	</template>

view raw drawingPadLWC.html hosted with ❤ by GitHub

	.pad {
	position: relative;
	cursor: crosshair;
	cursor: crosshair;
	-ms-touch-action: none;
	-webkit-user-select: none;
	-moz-user-select: none;
	-ms-user-select: none;
	-o-user-select: none;
	user-select: none;
	}

view raw drawingPadLWC.css hosted with ❤ by GitHub

Step: 3 - Now upload Jquery1_5_1.js and JQuerySignaturePad.js (files are attached) to static resources and Include  those in drawingPadLWC.js
Step: 4 - Have a look into renderedCallback()from drawingPadLWC.js 
where we have populated drawing canvas to ready for draw when run specific page.  signaturePad is calling to function that will be found  in JQuerySignaturePad.js  

Below example code will explain how possible rendering canvas to drawing mode.

	$drawn = this.template.querySelector('form');
	$(document).ready(function() {
	window.$($drawn).signaturePad({
	drawOnly: true,
	defaultAction: 'drawIt',
	validateFields: false,
	lineWidth: 0,
	clear: '.clearButton'
	});
	});

view raw example.js hosted with ❤ by GitHub

    Step: 5 - How to Save Your Drawing to related record of your object?
Apex Class DrawingPadHandler.cs is responsible to save drawing class where saveDiagram(..) method will be actioned from LWC javascript drawingPadLWC.js . This action defined in onclick button event which is defined in LWC html to drawingPadLWC.html 
<lightning-button variant="destructive" label="Save" title="Save" onclick={saveDrawing} class="slds-m-left_x-small"></lightning-button>
where onclick={saveDrawing} actually calling to javascript function in drawingPadLWC.js
saveDrawing (event) {...}
and that saveDrawing event function call to Apex class to handle save diagram in your Salesforce org as content attachment with specific record.

Please post comment to get complete AppExchange package Link.

Thank You to read this.

Here are sources inline -

	// drawingPadLWC.js
	import { LightningElement ,track, api} from 'lwc';
	import Jquery1_5_1 from "@salesforce/resourceUrl/Jquery1_5_1";
	import JQuerySignaturePad from "@salesforce/resourceUrl/JQuerySignaturePad";
	import { loadScript } from "lightning/platformResourceLoader";
	import { ShowToastEvent } from 'lightning/platformShowToastEvent';
	import saveDrawnimg from '@salesforce/apex/DrawingPadHandler.saveDiagram';
	var $drawn;
	export default class DrawingPadLWC extends LightningElement {
	@api recordId;
	@track cWidth ;
	@track cHeight;
	@track error;
	renderedCallback() {
	if(this.initialRender){return;}
	this.initialRender = true;
	this.onResize();
	loadScript(this, Jquery1_5_1 ).then(() => {
	loadScript(this, JQuerySignaturePad ).then(() => {
	console.log("JQuerySignaturePad Script loadedz...");
	// $canvas = this.template.querySelector('canvas');
	$drawn = this.template.querySelector('form');
	$(document).ready(function() {
	window.$($drawn).signaturePad({
	drawOnly: true,
	defaultAction: 'drawIt',
	validateFields: false,
	lineWidth: 0,
	clear: '.clearButton'
	});
	});
	});
	});
	}
	onResize(){
	var isMobile = /iPhone|iPad|iPod|Android|Mobile/i.test(navigator.userAgent);
	// alert ('navigator.userAgent '+ navigator.userAgent);
	if(isMobile){//mobile
	this.cWidth = window.innerWidth-5;
	this.cHeight = window.innerHeight;
	var isDeviceSpecific = /DeviceSpecificID|SM-T837A/i.test(navigator.userAgent);
	if(isDeviceSpecific){//DeviceSpecific for Samsung Galaxy Tab S4 (SM-T837A)
	this.cWidth = window.innerWidth+175;
	this.cHeight = window.innerHeight+30;
	}
	}else{//desktop
	this.cWidth = window.innerWidth/1.30;
	this.cHeight = window.innerHeight/1.55;
	}
	}
	saveDrawing (event) {
	var $drawnCanvas = this.template.querySelector('canvas');
	var drawnURL = $drawnCanvas.toDataURL("image/png");
	var drawnBaseURI = drawnURL.replace(/^data:image\/(png|jpg);base64,/, "");
	saveDrawnimg({signatureBody: drawnBaseURI,recordId: this.recordId})
	.then(result => {
	this.attachment = result;
	console.log('attachment id=' + this.attachment.Id);
	this.dispatchEvent(
	new ShowToastEvent({
	title: 'Success',
	message: 'Your Drawing Saved in files!',
	variant: 'success',
	}),
	);
	})
	.catch(error => {
	this.dispatchEvent(
	new ShowToastEvent({
	title: 'Error to Drawing Saved.',
	message: error.body.message,
	variant: 'error',
	}),
	);
	});
	}
	}

view raw drawingPadLWC.js hosted with ❤ by GitHub

	//DrawingPadHandler.cs
	public class DrawingPadHandler {
	@AuraEnabled
	public static String saveDiagram(String signatureBody, Id recordId){
	try{
	String contentDocumentId = NULL;
	// Query all Content Versions to Check for Previous Uploads.
	// If there is previous upload set that as the ContentDocumentID so that a new version can be uploaded to the same Document
	List<ContentVersion> convers = [SELECT Id, ContentDocumentId FROM ContentVersion WHERE Title =: 'PropertyDiagram.png' AND Description =: recordId AND IsLatest = TRUE];
	if(!convers.isEmpty()){
	contentDocumentId = convers[0].ContentDocumentId;
	}
	ContentVersion cv = new ContentVersion();
	cv.ContentLocation = 'S';
	cv.ContentDocumentId = contentDocumentId;
	cv.VersionData = EncodingUtil.base64Decode(signatureBody);
	cv.Title = 'DrawingPadDiagram.png';
	cv.PathOnClient = 'DrawingPadDiagram.png';
	cv.Description = recordId;
	insert cv;
	//***This DEBUG statement must return an Id for the rest of the code to work***
	System.debug('contentDocumentId='+[SELECT Id, ContentDocumentId FROM ContentVersion WHERE Id =: cv.Id].ContentDocumentId);
	ContentDistribution cd = new ContentDistribution();
	cd.Name = 'DrawingPadDiagram';
	cd.ContentVersionId = cv.id;
	cd.PreferencesAllowViewInBrowser= true;
	cd.PreferencesLinkLatestVersion=true;
	cd.PreferencesNotifyOnVisit=false;
	cd.PreferencesPasswordRequired=false;
	cd.PreferencesAllowOriginalDownload= false;
	insert cd;
	// Check to see if the ContentDocument is a brand new file
	if(convers.isEmpty()){
	ContentDocumentLink cdl = new ContentDocumentLink();
	cdl.ContentDocumentId = [SELECT Id, ContentDocumentId FROM ContentVersion WHERE Id =: cv.Id].ContentDocumentId;
	cdl.LinkedEntityId = recordId;
	cdl.ShareType = 'I';
	cdl.Visibility = 'AllUsers';
	insert cdl;
	}
	return '';
	}
	catch (Exception e)
	{
	String errorMessage = e.getMessage();
	Integer occurence;
	if (e.getMessage().contains('FIELD_CUSTOM_VALIDATION_EXCEPTION')){
	occurence = errorMessage.indexOf('FIELD_CUSTOM_VALIDATION_EXCEPTION,') + 34;
	errorMessage = errorMessage.mid(occurence, errorMessage.length());
	occurence = errorMessage.lastIndexOf(':');
	errorMessage = errorMessage.mid(0, occurence);
	}
	system.debug('Error: '+e);
	system.debug('Error: '+errorMessage);
	return errorMessage;
	}
	}
	}

view raw DrawingPadHandler.cs hosted with ❤ by GitHub

	//JQuerySignaturePad.js
	//This js would be refereneced and uploaded in static component
	//This function is work to plott your drawing smoothly through using JQuery and not need to any changes unless
	//to customise in addition use cases out of the box.
	(function ($) {
	function SignaturePad (selector, options) {
	/**
	* Reference to the object for use in public methods
	*
	* @private
	*
	* @type {Object}
	*/
	var self = this
	/**
	* Holds the merged default settings and user passed settings
	*
	* @private
	*
	* @type {Object}
	*/
	, settings = $.extend({}, $.fn.signaturePad.defaults, options)
	/**
	* The current context, as passed by jQuery, of selected items
	*
	* @private
	*
	* @type {Object}
	*/
	, context = $(selector)
	/**
	* jQuery reference to the canvas element inside the signature pad
	*
	* @private
	*
	* @type {Object}
	*/
	, canvas = $(settings.canvas, context)
	/**
	* Dom reference to the canvas element inside the signature pad
	*
	* @private
	*
	* @type {Object}
	*/
	, element = canvas.get(0)
	/**
	* The drawing context for the signature canvas
	*
	* @private
	*
	* @type {Object}
	*/
	, canvasContext = null
	/**
	* Holds the previous point of drawing
	* Disallows drawing over the same location to make lines more delicate
	*
	* @private
	*
	* @type {Object}
	*/
	, previous = {'x': null, 'y': null}
	/**
	* An array holding all the points and lines to generate the signature
	* Each item is an object like:
	* {
	* mx: moveTo x coordinate
	* my: moveTo y coordinate
	* lx: lineTo x coordinate
	* lx: lineTo y coordinate
	* }
	*
	* @private
	*
	* @type {Array}
	*/
	, output = []
	/**
	* Stores a timeout for when the mouse leaves the canvas
	* If the mouse has left the canvas for a specific amount of time
	* Stops drawing on the canvas
	*
	* @private
	*
	* @type {Object}
	*/
	, mouseLeaveTimeout = false
	/**
	* Whether the mouse button is currently pressed down or not
	*
	* @private
	*
	* @type {Boolean}
	*/
	, mouseButtonDown = false
	/**
	* Whether the browser is a touch event browser or not
	*
	* @private
	*
	* @type {Boolean}
	*/
	, touchable = false
	/**
	* Whether events have already been bound to the canvas or not
	*
	* @private
	*
	* @type {Boolean}
	*/
	, eventsBound = false
	/**
	* Remembers the default font-size when typing, and will allow it to be scaled for bigger/smaller names
	*
	* @private
	*
	* @type {Number}
	*/
	, typeItDefaultFontSize = 30
	/**
	* Remembers the current font-size when typing
	*
	* @private
	*
	* @type {Number}
	*/
	, typeItCurrentFontSize = typeItDefaultFontSize
	/**
	* Remembers how many characters are in the name field, to help with the scaling feature
	*
	* @private
	*
	* @type {Number}
	*/
	, typeItNumChars = 0
	/**
	* Clears the mouseLeaveTimeout
	* Resets some other variables that may be active
	*
	* @private
	*/
	function clearMouseLeaveTimeout () {
	clearTimeout(mouseLeaveTimeout)
	mouseLeaveTimeout = false
	mouseButtonDown = false
	}
	/**
	* Draws a line on canvas using the mouse position
	* Checks previous position to not draw over top of previous drawing
	* (makes the line really thick and poorly anti-aliased)
	*
	* @private
	*
	* @param {Object} e The event object
	* @param {Number} newYOffset A pixel value for drawing the newY, used for drawing a single dot on click
	*/
	function drawLine (e, newYOffset) {
	var offset, newX, newY
	e.preventDefault()
	offset = $(e.target).offset()
	clearTimeout(mouseLeaveTimeout)
	mouseLeaveTimeout = false
	if (typeof e.targetTouches !== 'undefined') {
	newX = Math.floor(e.targetTouches[0].pageX - offset.left)
	newY = Math.floor(e.targetTouches[0].pageY - offset.top)
	} else {
	newX = Math.floor(e.pageX - offset.left)
	newY = Math.floor(e.pageY - offset.top)
	}
	if (previous.x === newX && previous.y === newY)
	return true
	if (previous.x === null)
	previous.x = newX
	if (previous.y === null)
	previous.y = newY
	if (newYOffset)
	newY += newYOffset
	canvasContext.beginPath()
	canvasContext.moveTo(previous.x, previous.y)
	canvasContext.lineTo(newX, newY)
	canvasContext.lineCap = settings.penCap
	canvasContext.stroke()
	canvasContext.closePath()
	output.push({
	'lx' : newX
	, 'ly' : newY
	, 'mx' : previous.x
	, 'my' : previous.y
	})
	previous.x = newX
	previous.y = newY
	if (settings.onDraw && typeof settings.onDraw === 'function')
	settings.onDraw.apply(self)
	}
	/**
	* Callback wrapper for executing stopDrawing without the event
	* Put up here so that it can be removed at a later time
	*
	* @private
	*/
	function stopDrawingWrapper () {
	stopDrawing()
	}
	/**
	* Callback registered to mouse/touch events of the canvas
	* Stops the drawing abilities
	*
	* @private
	*
	* @param {Object} e The event object
	*/
	function stopDrawing (e) {
	if (!!e) {
	drawLine(e, 1)
	} else {
	if (touchable) {
	canvas.each(function () {
	this.removeEventListener('touchmove', drawLine)
	// this.removeEventListener('MSPointerMove', drawLine)
	})
	} else {
	canvas.unbind('mousemove.signaturepad')
	}
	if (output.length > 0 && settings.onDrawEnd && typeof settings.onDrawEnd === 'function')
	settings.onDrawEnd.apply(self)
	}
	previous.x = null
	previous.y = null
	if (settings.output && output.length > 0)
	$(settings.output, context).val(JSON.stringify(output))
	}
	/**
	* Draws the signature line
	*
	* @private
	*/
	function drawSigLine () {
	if (!settings.lineWidth)
	return false
	canvasContext.beginPath()
	canvasContext.lineWidth = settings.lineWidth
	canvasContext.strokeStyle = settings.lineColour
	canvasContext.moveTo(settings.lineMargin, settings.lineTop)
	canvasContext.lineTo(element.width - settings.lineMargin, settings.lineTop)
	canvasContext.stroke()
	canvasContext.closePath()
	}
	/**
	* Clears all drawings off the canvas and redraws the signature line
	*
	* @private
	*/
	function clearCanvas () {
	canvasContext.clearRect(0, 0, element.width, element.height)
	canvasContext.fillStyle = settings.bgColour
	canvasContext.fillRect(0, 0, element.width, element.height)
	if (!settings.displayOnly)
	drawSigLine()
	canvasContext.lineWidth = settings.penWidth
	canvasContext.strokeStyle = settings.penColour
	$(settings.output, context).val('')
	output = []
	stopDrawing()
	}
	/**
	* Callback registered to mouse/touch events of the canvas
	* Draws a line at the mouse cursor location, starting a new line if necessary
	*
	* @private
	*
	* @param {Object} e The event object
	* @param {Object} o The object context registered to the event; canvas
	*/
	function onMouseMove(e, o) {
	if (previous.x == null) {
	drawLine(e, 1)
	} else {
	drawLine(e, o)
	}
	}
	/**
	* Callback registered to mouse/touch events of canvas
	* Triggers the drawLine function
	*
	* @private
	*
	* @param {Object} e The event object
	* @param {Object} touchObject The object context registered to the event; canvas
	*/
	function startDrawing (e, touchObject) {
	if (touchable) {
	touchObject.addEventListener('touchmove', onMouseMove, false)
	// touchObject.addEventListener('MSPointerMove', onMouseMove, false)
	} else {
	canvas.bind('mousemove.signaturepad', onMouseMove)
	}
	// Draws a single point on initial mouse down, for people with periods in their name
	drawLine(e, 1)
	}
	/**
	* Removes all the mouse events from the canvas
	*
	* @private
	*/
	function disableCanvas () {
	eventsBound = false
	canvas.each(function () {
	if (this.removeEventListener) {
	this.removeEventListener('touchend', stopDrawingWrapper)
	this.removeEventListener('touchcancel', stopDrawingWrapper)
	this.removeEventListener('touchmove', drawLine)
	this.removeEventListener('touchstart', startTouchDrawing)
	// this.removeEventListener('MSPointerUp', stopDrawingWrapper)
	// this.removeEventListener('MSPointerCancel', stopDrawingWrapper)
	// this.removeEventListener('MSPointerMove', drawLine)
	}
	})
	$(document).unbind('mouseup.signaturepad')
	canvas.unbind('mousedown.signaturepad')
	canvas.unbind('mousemove.signaturepad')
	canvas.unbind('mouseleave.signaturepad')
	$(settings.clear, context).unbind('click.signaturepad')
	}
	/**
	* Lazy touch event detection
	* Uses the first press on the canvas to detect either touch or mouse reliably
	* Will then bind other events as needed
	*
	* @private
	*
	* @param {Object} e The event object
	*/
	function initDrawEvents (e) {
	if (eventsBound)
	return false
	eventsBound = true
	// Closes open keyboards to free up space
	$('input').blur();
	if (typeof e.targetTouches !== 'undefined')
	touchable = true
	if (touchable) {
	canvas.each(function () {
	this.addEventListener('touchend', stopDrawingWrapper, false)
	this.addEventListener('touchcancel', stopDrawingWrapper, false)
	// this.addEventListener('MSPointerUp', stopDrawingWrapper, false)
	// this.addEventListener('MSPointerCancel', stopDrawingWrapper, false)
	})
	canvas.unbind('mousedown.signaturepad')
	} else {
	$(document).bind('mouseup.signaturepad', function () {
	if (mouseButtonDown) {
	stopDrawing()
	clearMouseLeaveTimeout()
	}
	})
	canvas.bind('mouseleave.signaturepad', function (e) {
	if (mouseButtonDown) stopDrawing(e)
	if (mouseButtonDown && !mouseLeaveTimeout) {
	mouseLeaveTimeout = setTimeout(function () {
	stopDrawing()
	clearMouseLeaveTimeout()
	}, 500)
	}
	})
	canvas.each(function () {
	this.removeEventListener('touchstart', startTouchDrawing)
	})
	}
	}
	function startTouchDrawing(e) {
	e.preventDefault()
	mouseButtonDown = true
	initDrawEvents(e)
	startDrawing(e, this)
	}
	/**
	* Triggers the abilities to draw on the canvas
	* Sets up mouse/touch events, hides and shows descriptions and sets current classes
	*
	* @private
	*/
	function drawIt () {
	$(settings.typed, context).hide()
	clearCanvas()
	canvas.each(function () {
	this.addEventListener('touchstart', startTouchDrawing)
	})
	canvas.bind('mousedown.signaturepad', function (e) {
	e.preventDefault()
	// Only allow left mouse clicks to trigger signature drawing
	if (e.which > 1) return false
	mouseButtonDown = true
	initDrawEvents(e)
	startDrawing(e)
	})
	$(settings.clear, context).bind('click.signaturepad', function (e) { e.preventDefault(); clearCanvas() })
	$(settings.typeIt, context).bind('click.signaturepad', function (e) { e.preventDefault(); typeIt() })
	$(settings.drawIt, context).unbind('click.signaturepad')
	$(settings.drawIt, context).bind('click.signaturepad', function (e) { e.preventDefault() })
	$(settings.typeIt, context).removeClass(settings.currentClass)
	$(settings.drawIt, context).addClass(settings.currentClass)
	$(settings.sig, context).addClass(settings.currentClass)
	$(settings.typeItDesc, context).hide()
	$(settings.drawItDesc, context).show()
	$(settings.clear, context).show()
	}
	/**
	* Triggers the abilities to type in the input for generating a signature
	* Sets up mouse events, hides and shows descriptions and sets current classes
	*
	* @private
	*/
	function typeIt () {
	clearCanvas()
	disableCanvas()
	$(settings.typed, context).show()
	$(settings.drawIt, context).bind('click.signaturepad', function (e) { e.preventDefault(); drawIt() })
	$(settings.typeIt, context).unbind('click.signaturepad')
	$(settings.typeIt, context).bind('click.signaturepad', function (e) { e.preventDefault() })
	$(settings.output, context).val('')
	$(settings.drawIt, context).removeClass(settings.currentClass)
	$(settings.typeIt, context).addClass(settings.currentClass)
	$(settings.sig, context).removeClass(settings.currentClass)
	$(settings.drawItDesc, context).hide()
	$(settings.clear, context).hide()
	$(settings.typeItDesc, context).show()
	typeItCurrentFontSize = typeItDefaultFontSize = $(settings.typed, context).css('font-size').replace(/px/, '')
	}
	/**
	* Callback registered on key up and blur events for input field
	* Writes the text fields value as Html into an element
	*
	* @private
	*
	* @param {String} val The value of the input field
	*/
	function type (val) {
	var typed = $(settings.typed, context)
	, cleanedVal = $.trim(val.replace(/>/g, '&gt;').replace(/</g, '&lt;'))
	, oldLength = typeItNumChars
	, edgeOffset = typeItCurrentFontSize * 0.5
	typeItNumChars = cleanedVal.length
	typed.html(cleanedVal)
	if (!cleanedVal) {
	typed.css('font-size', typeItDefaultFontSize + 'px')
	return
	}
	if (typeItNumChars > oldLength && typed.outerWidth() > element.width) {
	while (typed.outerWidth() > element.width) {
	typeItCurrentFontSize--
	typed.css('font-size', typeItCurrentFontSize + 'px')
	}
	}
	if (typeItNumChars < oldLength && typed.outerWidth() + edgeOffset < element.width && typeItCurrentFontSize < typeItDefaultFontSize) {
	while (typed.outerWidth() + edgeOffset < element.width && typeItCurrentFontSize < typeItDefaultFontSize) {
	typeItCurrentFontSize++
	typed.css('font-size', typeItCurrentFontSize + 'px')
	}
	}
	}
	/**
	* Default onBeforeValidate function to clear errors
	*
	* @private
	*
	* @param {Object} context current context object
	* @param {Object} settings provided settings
	*/
	function onBeforeValidate (context, settings) {
	$('p.' + settings.errorClass, context).remove()
	context.removeClass(settings.errorClass)
	$('input, label', context).removeClass(settings.errorClass)
	}
	/**
	* Default onFormError function to show errors
	*
	* @private
	*
	* @param {Object} errors object contains validation errors (e.g. nameInvalid=true)
	* @param {Object} context current context object
	* @param {Object} settings provided settings
	*/
	function onFormError (errors, context, settings) {
	if (errors.nameInvalid) {
	context.prepend(['<p class="', settings.errorClass, '">', settings.errorMessage, '</p>'].join(''))
	$(settings.name, context).focus()
	$(settings.name, context).addClass(settings.errorClass)
	$('label[for=' + $(settings.name).attr('id') + ']', context).addClass(settings.errorClass)
	}
	if (errors.drawInvalid)
	context.prepend(['<p class="', settings.errorClass, '">', settings.errorMessageDraw, '</p>'].join(''))
	}
	/**
	* Validates the form to confirm a name was typed in the field
	* If drawOnly also confirms that the user drew a signature
	*
	* @private
	*
	* @return {Boolean}
	*/
	function validateForm () {
	var valid = true
	, errors = {drawInvalid: false, nameInvalid: false}
	, onBeforeArguments = [context, settings]
	, onErrorArguments = [errors, context, settings]
	if (settings.onBeforeValidate && typeof settings.onBeforeValidate === 'function') {
	settings.onBeforeValidate.apply(self,onBeforeArguments)
	} else {
	onBeforeValidate.apply(self, onBeforeArguments)
	}
	if (settings.drawOnly && output.length < 1) {
	errors.drawInvalid = true
	valid = false
	}
	if ($(settings.name, context).val() === '') {
	errors.nameInvalid = true
	valid = false
	}
	if (settings.onFormError && typeof settings.onFormError === 'function') {
	settings.onFormError.apply(self,onErrorArguments)
	} else {
	onFormError.apply(self, onErrorArguments)
	}
	return valid
	}
	/**
	* Redraws the signature on a specific canvas
	*
	* @private
	*
	* @param {Array} paths the signature JSON
	* @param {Object} context the canvas context to draw on
	* @param {Boolean} saveOutput whether to write the path to the output array or not
	*/
	function drawSignature (paths, context, saveOutput) {
	for(var i in paths) {
	if (typeof paths[i] === 'object') {
	context.beginPath()
	context.moveTo(paths[i].mx, paths[i].my)
	context.lineTo(paths[i].lx, paths[i].ly)
	context.lineCap = settings.penCap
	context.stroke()
	context.closePath()
	if (saveOutput && paths[i].lx) {
	output.push({
	'lx' : paths[i].lx
	, 'ly' : paths[i].ly
	, 'mx' : paths[i].mx
	, 'my' : paths[i].my
	})
	}
	}
	}
	}
	/**
	* Initialisation function, called immediately after all declarations
	* Technically public, but only should be used internally
	*
	* @private
	*/
	function init () {
	// Fixes the jQuery.fn.offset() function for Mobile Safari Browsers i.e. iPod Touch, iPad and iPhone
	// https://gist.github.com/661844
	// http://bugs.jquery.com/ticket/6446
	if (parseFloat(((/CPU.+OS ([0-9_]{3}).*AppleWebkit.*Mobile/i.exec(navigator.userAgent)) || [0,'4_2'])[1].replace('_','.')) < 4.1) {
	$.fn.Oldoffset = $.fn.offset;
	$.fn.offset = function () {
	var result = $(this).Oldoffset()
	result.top -= window.scrollY
	result.left -= window.scrollX
	return result
	}
	}
	// Disable selection on the typed div and canvas
	$(settings.typed, context).bind('selectstart.signaturepad', function (e) { return $(e.target).is(':input') })
	canvas.bind('selectstart.signaturepad', function (e) { return $(e.target).is(':input') })
	if (!element.getContext && FlashCanvas)
	FlashCanvas.initElement(element)
	if (element.getContext) {
	canvasContext = element.getContext('2d')
	$(settings.sig, context).show()
	if (!settings.displayOnly) {
	if (!settings.drawOnly) {
	$(settings.name, context).bind('keyup.signaturepad', function () {
	type($(this).val())
	})
	$(settings.name, context).bind('blur.signaturepad', function () {
	type($(this).val())
	})
	$(settings.drawIt, context).bind('click.signaturepad', function (e) {
	e.preventDefault()
	drawIt()
	})
	}
	if (settings.drawOnly || settings.defaultAction === 'drawIt') {
	drawIt()
	} else {
	typeIt()
	}
	if (settings.validateFields) {
	if ($(selector).is('form')) {
	$(selector).bind('submit.signaturepad', function () { return validateForm() })
	} else {
	$(selector).parents('form').bind('submit.signaturepad', function () { return validateForm() })
	}
	}
	$(settings.sigNav, context).show()
	}
	}
	}
	$.extend(self, {
	/**
	* A property to store the current version of Signature Pad
	*/
	signaturePad : '{{version}}'
	/**
	* Initializes SignaturePad
	*/
	, init : function () { init() }
	/**
	* Allows options to be updated after initialization
	*
	* @param {Object} options An object containing the options to be changed
	*/
	, updateOptions : function (options) {
	$.extend(settings, options)
	}
	/**
	* Regenerates a signature on the canvas using an array of objects
	* Follows same format as object property
	* @see var object
	*
	* @param {Array} paths An array of the lines and points
	*/
	, regenerate : function (paths) {
	self.clearCanvas()
	$(settings.typed, context).hide()
	if (typeof paths === 'string')
	paths = JSON.parse(paths)
	drawSignature(paths, canvasContext, true)
	if (settings.output && $(settings.output, context).length > 0)
	$(settings.output, context).val(JSON.stringify(output))
	}
	/**
	* Clears the canvas
	* Redraws the background colour and the signature line
	*/
	, clearCanvas : function () { clearCanvas() }
	/**
	* Returns the signature as a Js array
	*
	* @return {Array}
	*/
	, getSignature : function () { return output }
	/**
	* Returns the signature as a Json string
	*
	* @return {String}
	*/
	, getSignatureString : function () { return JSON.stringify(output) }
	/**
	* Returns the signature as an image
	* Re-draws the signature in a shadow canvas to create a clean version
	*
	* @return {String}
	*/
	, getSignatureImage : function () {
	var tmpCanvas = document.createElement('canvas')
	, tmpContext = null
	, data = null
	tmpCanvas.style.position = 'absolute'
	tmpCanvas.style.top = '-999em'
	tmpCanvas.width = element.width
	tmpCanvas.height = element.height
	document.body.appendChild(tmpCanvas)
	if (!tmpCanvas.getContext && FlashCanvas)
	FlashCanvas.initElement(tmpCanvas)
	tmpContext = tmpCanvas.getContext('2d')
	tmpContext.fillStyle = settings.bgColour
	tmpContext.fillRect(0, 0, element.width, element.height)
	tmpContext.lineWidth = settings.penWidth
	tmpContext.strokeStyle = settings.penColour
	drawSignature(output, tmpContext)
	data = tmpCanvas.toDataURL.apply(tmpCanvas, arguments)
	document.body.removeChild(tmpCanvas)
	tmpCanvas = null
	return data
	}
	/**
	* The form validation function
	* Validates that the signature has been filled in properly
	* Allows it to be hooked into another validation function and called at a different time
	*
	* @return {Boolean}
	*/
	, validateForm : function () { return validateForm() }
	})
	}
	/**
	* Create the plugin
	* Returns an Api which can be used to call specific methods
	*
	* @param {Object} options The options array
	*
	* @return {Object} The Api for controlling the instance
	*/
	$.fn.signaturePad = function (options) {
	var api = null
	this.each(function () {
	if (!$.data(this, 'plugin-signaturePad')) {
	api = new SignaturePad(this, options)
	api.init()
	$.data(this, 'plugin-signaturePad', api)
	} else {
	api = $.data(this, 'plugin-signaturePad')
	api.updateOptions(options)
	}
	})
	return api
	}
	/**
	* Expose the defaults so they can be overwritten for multiple instances
	*
	* @type {Object}
	*/
	$.fn.signaturePad.defaults = {
	defaultAction : 'typeIt' // What action should be highlighted first: typeIt or drawIt
	, displayOnly : false // Initialize canvas for signature display only; ignore buttons and inputs
	, drawOnly : false // Whether the to allow a typed signature or not
	, canvas : 'canvas' // Selector for selecting the canvas element
	, sig : '.sig' // Parts of the signature form that require Javascript (hidden by default)
	, sigNav : '.sigNav' // The TypeIt/DrawIt navigation (hidden by default)
	, bgColour : '#ffffff' // The colour fill for the background of the canvas; or transparent
	, penColour : '#145394' // Colour of the drawing ink
	, penWidth : 2 // Thickness of the pen
	, penCap : 'round' // Determines how the end points of each line are drawn (values: 'butt', 'round', 'square')
	, lineColour : '#ccc' // Colour of the signature line
	, lineWidth : 2 // Thickness of the signature line
	, lineMargin : 5 // Margin on right and left of signature line
	, lineTop : 35 // Distance to draw the line from the top
	, name : '.name' // The input field for typing a name
	, typed : '.typed' // The Html element to accept the printed name
	, clear : '.clearButton' // Button for clearing the canvas
	, typeIt : '.typeIt a' // Button to trigger name typing actions (current by default)
	, drawIt : '.drawIt a' // Button to trigger name drawing actions
	, typeItDesc : '.typeItDesc' // The description for TypeIt actions
	, drawItDesc : '.drawItDesc' // The description for DrawIt actions (hidden by default)
	, output : '.output' // The hidden input field for remembering line coordinates
	, currentClass : 'current' // The class used to mark items as being currently active
	, validateFields : true // Whether the name, draw fields should be validated
	, errorClass : 'error' // The class applied to the new error Html element
	, errorMessage : 'Please enter your name' // The error message displayed on invalid submission
	, errorMessageDraw : 'Please sign the document' // The error message displayed when drawOnly and no signature is drawn
	, onBeforeValidate : null // Pass a callback to be used instead of the built-in function
	, onFormError : null // Pass a callback to be used instead of the built-in function
	, onDraw : null // Pass a callback to be used to capture the drawing process
	, onDrawEnd : null // Pass a callback to be exectued after the drawing process
	}
	}(jQuery));

view raw JQuerySignaturePad.js hosted with ❤ by GitHub

Attached minified js files for static resource:
jquery.signaturepad.min.js and
jquery.min.js

Ref:

https://developer.salesforce.com/docs/component-library/documentation/en/lwc
https://www.jqueryscript.net/other/Smooth-Signature-Pad-Plugin-with-jQuery-Html5-Canvas.html
https://developer.salesforce.com/docs/component-library/documentation/en/lwc/lwc.create_lifecycle_hooks_rendered

Implement Salesforce Custom Notification Actions using Apex code Rest API Included Test Class

‪Code Way You to start with creating a Salesforce custom notification, enable Lightning Experience & Mobile App notifications!!‬

Custom Notification is very important to send alerts on desktop and/or mobile & keep your users in the know when important. Sometimes it is necessary to use custom Apex code instead using Process Builder or Flow. 

Here I tried to write code with schedular to run autonomously as cron job by Apex Schedular Class.

This Example will show how to trigger Alert to an Opportunity owner in day to Opportunity  Closing date , or this class can be reused for any objects with custom message with minimum required re coding. I have in Included Test Class too .

Before you send a custom notification, you must first create a notification type: 

How to create a Notification Type :

To send custom notifications via a process in Process Builder, a Flow in Flow Builder, or invocable action API you must Create notification types.

1. Enter Notification Builder in the Quick Find box in Setup, then select Custom Notifications.
2. Click New and add your Custom Notification Name and API Name, and supported channels.
3. Save your notification type.
4. If you enable the mobile channel, you must enable the supported apps for your notification type.
   1. From Setup, enter Notification Builder in the Quick Find box, then select Notification Delivery Settings.
   2. Choose your custom notification type, and select Edit from the dropdown menu.
   3. Select the supported applications for your notification type and save.

Supported REST HTTP Methods

* This object is available in API version 46.0 and later.

URI

/vXX.X/actions/standard/customNotificationAction

Formats

JSON, XML

HTTP Methods

GET, HEAD, POST

Authentication

Authorization: Bearer token

Inputs

Input	Details
customNotifTypeId	The ID of the Custom Notification Type being used for the notification.
recipientIds	The ID of the recipient or recipient type of the notification. UserId — The notification will be sent to this user, if this user is active. Values can be combined in a list up to the maximum of 500 values.
senderId	The User ID of the sender of the notification.
title	The title of the notification, as it will be seen by recipients. Maximum characters: 250.
body	body of the notification, as it will be seen by recipients. Maximum characters: 750.
targetId	The Record ID for the target record of the notification.

Sample Output:

 

Class CustNotify will get Notification Type Id, Generate JSON and call REST API to Trigger Bulk/single Notification for Object Owner !!

String NotifTypeID = [SELECT Id FROM CustomNotificationType WHERE DeveloperName = :NotifiDeveloperName].Id;

above SOQL will get Notification Type Id by passing Notification Developer Name.

Here is the Code Example :

	public with sharing class CustNotify {
	public static void (String NotifiDeveloperName, list<sObject> lstObjects, String NotifTitle, String NotifBody) {
	String NotifTypeID =
	[SELECT Id FROM CustomNotificationType WHERE DeveloperName = :NotifiDeveloperName].Id;
	if(!lstObjects.isEmpty()) {
	JSONGenerator jsAttr = JSON.createGenerator(true);
	jsAttr.writeStartObject();
	jsAttr.writeFieldName('inputs');
	jsAttr.writeStartArray();
	for(sObject obj : lstObjects) {
	jsAttr.writeStartObject();
	jsAttr.writeStringField('customNotifTypeId', NotifTypeID);
	jsAttr.writeFieldName('recipientIds');
	jsAttr.writeStartArray();
	jsAttr.writeId((Id)obj.get('OwnerId'));
	jsAttr.writeEndArray();
	jsAttr.writeStringField('title', (String)obj.get('Name') + NotifTitle);
	jsAttr.writeStringField('body', (String)obj.get('Name') + NotifBody);
	jsAttr.writeStringField('targetId', (String)obj.get('Id'));
	jsAttr.writeEndObject();
	}
	jsAttr.writeEndArray();
	jsAttr.writeEndObject();
	String strJson = jsAttr.getAsString();
	String strPOSTURL = 'actions/standard/customNotificationAction';
	String strPostResponse = httpRequest(strPOSTURL, 'POST', strJson);
	}
	}
	//HTTP Call out
	public static String httpRequest(String strResourceName, String strMethod, String strBody) {
	String response;
	String strEndPonitURL = URL.getSalesforceBaseUrl().toExternalForm() + '/services/data/v46.0/' + strResourceName;
	if(String.isNotBlank(strResourceName)) {
	HttpRequest httpRequest = new HttpRequest();
	httpRequest.setMethod(strMethod);
	httpRequest.setHeader('Authorization', 'OAuth ' + UserInfo.getSessionId());
	httpRequest.setHeader('Authorization', 'Bearer ' + UserInfo.getSessionID());
	if(String.isNotBlank(strBody)) {
	httpRequest.setBody(strBody);
	httpRequest.setHeader('Content-Type', 'application/json');
	httpRequest.setHeader('Accept', 'application/json');
	}
	httpRequest.setEndpoint(strEndPonitURL);
	try {
	Http http = new Http();
	HttpResponse httpResponse = http.send(httpRequest);
	if (httpResponse.getStatusCode() == 200 ) {
	response = httpResponse.getBody();
	}
	else {
	throw new CalloutException(httpResponse.getBody());
	}
	}
	catch(Exception ex) {
	throw ex;
	}
	}
	return response;
	}
	}

view raw CustNotify.cls hosted with ❤ by GitHub

  and this Schedule Class is to Execute CustNotify ! 

	public with sharing class CustNotifyScheduledCron implements Schedulable{
	public static void execute(SchedulableContext SC) {
	list<Opportunity> listOpps = [SELECT Id, Name, OwnerId FROM Opportunity WHERE CloseDate =:Date.today()];
	CustNotify.sendCustomNotification
	('Custom_Notification_on_Date_Ending', listOpps, ' Opportunity Closed Date is Today ' , ' Closed Date '+Date.today());
	}
	}

view raw CustNotifyScheduledCron.cls hosted with ❤ by GitHub

And my use case was to execute Every Midnight    to schedule to Notify Opportunity Owners .

System.schedule('Scheduled CustNotify', '0 0 0 * * ?', new CustNotifyScheduledCron ());

 

Here is the Test Class

 

	@isTest
	public with sharing class TestCustNotify {
	@TestSetup
	static void insertNewOpportunity() {
	Account objAccount = new Account(Name = 'Test Acc1', BillingCity = 'Test City', BillingState = 'Test State',
	BillingStreet = 'Test Street', BillingPostalCode = '12345',
	BillingCountry = 'Test Country', Phone = '123456');
	insert objAccount;
	Opportunity objOpp = new Opportunity(Name = 'Test Opp', AccountId = objAccount.Id, StageName = 'Verbal Confirmation', CloseDate = Date.today());
	insert objOpp;
	}
	@IsTest
	static void methodTest() {
	Test.startTest();
	SchedulableContext sc = null;
	try {
	CustNotifyScheduledCron.execute(sc);
	}catch(Exception e) {
	}
	Test.stopTest();
	}
	}

view raw TestCustNotify.cls hosted with ❤ by GitHub

Ref: 

https://developer.salesforce.com/docs/atlas.en-us.api_action.meta/api_action/actions_obj_custom_notification.htm

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

Salesforce Admin Interview Questions

(1). What is the difference between public cloud and private cloud? Is salesforce.com is a public cloud or private cloud?

Public Cloud: Cloud services are provided “as a service” over the Internet with little or no control over the underlying technology infrastructure. More than one tenant can use the same resources.

Private Cloud: This also offers activities and functions “as a service” but is deployed over a company intranet or hosted datacenter. This is private product for a company or organization offering advance security.

Salesforce.com: Is a public cloud as it is hosted on salesforce.com data centers and data of more than one tenant resides on same servers.

(2).What are different kinds of reports?

1. Tabular: Tabular 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. Examples include contact mailing lists and activity reports.

2. Summary: Summary reports are similar to tabular reports, but also allow users to group rows of data, view subtotals, and create charts. They can be used as the source report for dashboard components. Use this type for a report to show subtotals based on the value of a particular field or when you want to create a hierarchical list, such as all opportunities for your team, subtotaled by Stage and Owner. Summary reports with no groupings show as tabular reports on the report run page.

3. Matrix: Matrix 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.

4. Joined: Joined reports let you create multiple report blocks that provide different views of your data. Each block acts like a “sub-report,” with its own fields, columns, sorting, and filtering. A joined report can even contain data from different report types.

(3). What are different kinds of dashboard component?

1. Chart: Use a chart when you want to show data graphically.

2. Gauge: Use a gauge when you have a single value that you want to show within a range of custom values.

3. Metric: Use a metric when you have one key value to display.

• Enter metric labels directly on components by clicking the empty text field next to the grand total.
• Metric components placed directly above and below each other in a dashboard column are displayed together as a single component.

4. Table: Use a table to show a set of report data in column form.

5. Visualforce Page: Use a Visualforce page when you want to create a custom component or show information not available in another component type

6. Custom S-Control: Custom S-Controls can contain any type of content that you can display or run in a browser, for example, a Java applet, an ActiveX control, an Excel file, or a custom HTML Web form

(4). What actions can be performed using Workflows?

Following workflow actions can be performed in a workflow:

1. Email Alert:

Email alerts are workflow and approval actions that are generated using an email template by a workflow rule or approval process and sent to designated recipients, either Salesforce users or others. Workflow alerts can be sent to any user or contact, as long as they have a valid email address.

2. Field Update:

Field updates are workflow and approval actions that specify the field you want updated and the new value for it. Depending on the type of field, you can choose to apply a specific value, make the value blank, or calculate a value based on a formula you create.

3. Task:

Assigns a task to a user you specify. You can specify the Subject, Status, Priority, and Due Dateof the task. Tasks are workflow and approval actions that are triggered by workflow rules or approval processes.

4. Outbound Message:

An outbound message is a workflow, approval, or milestone action that sends the information you specify to an endpoint you designate, such as an external service. An outbound message sends the data in the specified fields in the form of a SOAP message to the endpoint.

(5). What are groups in SFDC and what is their use?

Groups are sets of users. They can contain individual users, other groups, the users in a particular role or territory, or the users in a particular role or territory plus all of the users below that role or territory in the hierarchy.

There are two types of groups:

• Public groups: Only administrators can create public groups. They can be used by everyone in the organization.
• Personal groups: Each user can create groups for their personal use.

You can use groups in the following ways:

• To set up default sharing access via a sharing rule
• To share your records with other users
• To specify that you want to synchronize contacts owned by others users
• To add multiple users to a Salesforce CRM Content library
• To assign users to specific actions in Salesforce Knowledge

(6). What is Visualforce View State?

Visualforce pages that contain a form component also contain an encrypted, hidden form field that encapsulates the view state of the page. This view state is automatically created, and as its name suggests, it holds the state of the page – state that includes the components, field values and controller state.

Note:

• Minimize number of form on a page.  Use apex:actionRegion instead of using 2 or more forms.
• Refine your SOQL to only retrieve the data needed by the page.
• All public and private data members present in Standard, Custom and Controller extensions are saved.
• The transient variables are not passed to view state and therefore not stored in View State.

For more information please refer to the link:

How to enable view state in Salesforce

http://theblogreaders.com/maximum-view-state-size-limit-exceeded-in-salesforce

http://wiki.developerforce.com/page/An_Introduction_to_Visualforce_View_State

(7). Which objects can be imported by Import Wizard?

Following objects can be imported using import wizard.

Accounts
Contacts
Leads
Solutions
Custom Objects

(8). What is Profile and Components?

profile contains user permissions and access settings that control what users can do within their organization.

A collection of settings and permissions that define how a user accesses records
– Determines how users see data and what they can do within the application
– A profile can have many users, but a user can have only one profile

Profiles Components:

• Which standard and custom apps users can view
• Which tabs users can view
• Which record types are available to users
• Which page layouts users see
• Object permissions that allow users to create, read, edit, and delete records
• Which fields within objects users can view and edit
• Permissions that allow users to manage the system and apps within it
• Which Apex classes and Visualforce pages users can access
• Which desktop clients users can access
• The hours during which and IP addresses from which users can log in
• Which service providers users can access (if Salesforce is enabled as an identity provider)

(9). What is PermissionSet?

PermissionSet represents a set of permissions that’s used to grant additional access to one or more users without changing their profile or reassigning profiles. You can use permission sets to grant access, but not to deny access.

Every PermissionSet is associated with a user license. You can only assign permission sets to users who have the same user license that’s associated with the permission set. If you want to assign similar permissions to users with different licenses, create multiple permission sets with the same permissions, but with different licenses.

Permission sets include settings for:

• Assigned apps
• Object settings, which include:
  • Tab settings
  • Object permissions
  • Field permissions
• App permissions
• Apex class access
• Visualforce page access
• System permissions
• Service providers (only if you’ve enabled Salesforce as an identity provider)

(10). Profile Vs Permission Sets Permissions and Access Settings?

1. User permissions and access settings specify what users can do within an organization.

2. Permissions and access settings are specified in user profiles and permission sets. Every user is assigned only one profile, but can also have multiple permission sets.

3. When determining access for your users, it’s a good idea to use profiles to assign the minimum permissions and access settings for specific groups of users, then use permission sets to grant additional permissions.

The following table shows the types of permissions and access settings that are specified in profiles and permission sets. Some profile settings aren’t included in permission sets.

Permission or Setting Type	In Profiles?	In Permission Sets?
Assigned apps	TRUE	TRUE
Tab settings	TRUE	TRUE
Record type assignments	TRUE
Page layout assignments	TRUE
Object permissions	TRUE	TRUE
Field permissions	TRUE	TRUE
User permissions (app and system)	TRUE	TRUE
Apex class access	TRUE	TRUE
Visualforce page access	TRUE	TRUE
Service provider access (if Salesforce is enabled as an identity provider)	TRUE	TRUE
Desktop client access	TRUE
Login hours	TRUE
Login IP ranges	TRUE

http://login.salesforce.com/help/doc/en/perm_sets_overview.htm

(11). What are the Standard Profiles available in Salesforce?

Six (6) Standard Profiles  (EE/UE and PE)

• Standard User – Can view, edit, and delete their own records

• Solution Manager – Standard User permissions + Can manage published solutions + Can manage categories

• Marketing User – Standard User permissions + Can import leads for the organization

• Contract Manager – Standard User permissions + Can edit, approve, activate, and delete contracts

• Read-Only – Can only view records

• System Administrator – “Super User,” can customize and administer the application

(12). What is the Force.com Platform?

- Customize, integrate and create enterprise applications as a service and without software.
- Customize standard applications provided by salesforce.com or build their own on-demand applications
- Group standard and custom tabs into new custom applications

(13). Salesforce Editions and Limits?

- Personal Edition
- Contact Manager
- Group Edition
- Professional Edition
- Enterprise Edition
- Unlimited Edition
- Developer Edition

http://login.salesforce.com/help/doc/en/limits.htm

(14). What are Standard Business Objects?

• Campaigns: A Campaign is any marketing project that you want to plan, manage, and track in Salesforce.
• Leads: A Lead is any person, organization or company that may be interested in your products. Sometimes Leads are referred to as Prospects or Suspects. Leads are not yet customers.
• Accounts: An Account is an organization, individual or company involved with your business such as customers, competitors and partners that you wish to track in Salesforce.
• Contacts: A Contact is any individual or influencer associated with an account that you want to track in Salesforce.
• Opportunities: An Opportunity is any potential revenue-generating event (“sales deal” ) that you want to
track in Salesforce.
• Cases: A case is a detailed description of a customer’s feedback, problem or question.
• Solutions: A solution is a detailed description of a customer issue and the resolution of that issue. The
collection of your organization’s solutions is sometimes referred to as the solution knowledge base.
• Forecasts: A forecast is your best estimate of how much revenue you can generate in a quarter.
• Documents:
• Reports: Reports are summaries and analyses of your data, which you can display or print.
• Dashboards: Dashboards give you a real-time snapshot of corporate metrics and key performance
indicators. A dashboard is a group of different charts (or components) that graphically display your custom
report data.
• Calendar and Task: Activities are both tasks and scheduled calendar events. You can define and track
activities for many different objects, including campaigns, accounts, contacts, and leads.
• Products: Products are the individual items that you sell on your opportunities. (Please note that Products are available in EE/UE and Developer and in PE for an additional fee.)
Please note, not all Standard Objects are depicted in the above slide or discussed in the notes.
Please refer to Help in Salesforce for more information.

Standard Objects

Data Model

(15). What is a Company Profile?

Contains core information for your company
• Language, Locale and Time Zone
• Licenses
• Storage and Used Space
• Fiscal Year
• Primary Contact and Address information
• Manage Currencies

(16). What is a Fiscal Year in Salesforce?

– Used for an organizations financial planning
– Usually a year in length
– Impacts forecasts, quotas and reports
Salesforce allows two types:
–Standard Fiscal Years are periods that follow the Gregorian calendar, but can start on the first day of any
month of the year. (A Gregorian Year is a calendar based on a 12 Month Structure and is used throughout
much of the world.)
–Custom Fiscal Years are for companies that break down their fiscal years, quarters and weeks in to custom fiscal periods based on their financial planning requirements.

• Forecasting can NOT be used with Custom Fiscal Years

• Customizable Forecasting must be enabled for use with Custom Fiscal Years

(17). What is Standard and Custom Fields in Salesforce?

Standard Fields
What is a Standard Field?
– Standard Fields are pre-defined in Salesforce
– You cannot delete standard fields but you can remove non-required standard fields from a page layout
Standard Field customizations include the ability to change standard field labels and tabs

• You can change the display labels of standard tabs, objects, fields, and other related user interface labels so they better reflect your organization’s business requirements.

• Renamed labels – for example, “Accounts” changed to “Companies” – display on all user pages, in Outlook Edition, and in Offline Edition.

• It’s important to note that all pages in the Setup area use the default, original labels.

• Reports and views are not renamed based on the new label value.

Custom Fields
What is a Custom Field?
– Capture information unique to your business process by creating custom fields with custom field help for  each of the tabs that your organization uses – Limits:
https://na1.salesforce.com/help/doc/en/limits.htm
–Recycle Bin for Deleted Custom Fields
–Custom fields are deleted permanently after 45 days

(18). Is it possible to change the existing data types of custom fields, if Yes please explanin?

Yes. Its possible but Changing the data type of an existing custom field can cause data loss in the following situations:

• Changing to or from type Date or Date/Time

• Changing to Number from any other type

• Changing to Percent from any other type

• Changing to Currency from any other type

• Changing from Checkbox to any other type

• Changing from Picklist (Multi-Select) to any other type

• Changing to Picklist (Multi-Select) from any type except Picklist

• Changing from Auto Number to any other type

• Changing to Auto Number from any type except Text

• Changing from Text Area (Long) to any type except Email, Phone, Text, Text Area, or URL

(19). What is a dependent picklist?

– Dependent fields can help make your data more accurate and consistent by applying filters.
– A dependent field works in conjunction with a controlling field to filter its values. The value chosen in the controlling field affects the values available in the dependent field.
– 300 is the maximum number of values allowed in a controlling picklist
- A custom multi-select picklist cannot be the controlling field for a dependent field

Field Type	Controlling Field	Dependent Field
Standard Picklist	Yes	No
Custom Picklist	Yes	Yes
Custom Multi-Select	No	Yes
Standard Checkbox	Yes	No
Custom Checkbox	Yes	No

(20). What is Page Layout and Record Types?

Page Layout:

– How detail and edit pages are organized
– Page section customizations
– Which fields, related lists, and Custom Links a users sees
– Field properties – visible, read-only and required

Record Types:

– Allows you to define different sets of picklist values for both standard and custom picklists
– Record Types help you implement your custom business processes

(21). What is a Business Process?

• Allows you to track separate sales, support, and lead lifecycles
across different divisions, groups, or markets

Available Business Processes:
– Sales Processes – Create different sales processes that include some or all of the picklist values available for the Opportunity Stage field
– Support Processes – Create different support processes that include some or all of the picklist values available for the Case Status field
– Lead Processes – Create different lead processes that include some or all of the picklist values available for the Lead Status field
– Solution Processes – Create different solution processes that include some or all of the picklist values available for the Solution Status field

(22). What are the Objects available in the Salesforce Business Process and Give some Business Process Example?

Lead
Opportunity
Case
Solution

–You must create the business process before creating record types for each of above objects.

– You can then associate each business process with one or more record types and make it available to users based on their profile.
– In order to implement more than one business process, multiple record types must also be implemented.

Business Process Examples
Lead Processes:
– Cold Call
– 3rd Party telesales companies
– Leads generated via campaigns
– Leads generated via a registration form

Opportunities Sales Processes:
– Miller Heiman/ Solution Selling Methodology
– Inside Sales vs. Outside Sales
– New business vs. Existing Business (Up selling)

Case Processes:
– Customer Inquiries
– Internal Requests
– Billing inquiries

Solutions Processes:
– Internal vs. Public Knowledge Base

(23). What about Web-to-Lead and Web-to-Case?

–A lead or case record created through Web-to-Lead or Web-to-Case will set the record type to that of  the default lead owner or automated case user (optional)

(24). On which tabs can I create multiple record types?

–Multiple record types may be created for every tab, with the exception of the Home, Forecasts, Documents, and Reports tabs.

(25). What happens if I need to add a picklist value?

–You will be prompted to select which record types should include the new value

(26). What is Field-Level Security?

– Defines users’ access to view and edit specific fields in the application

(27). Why use Field-Level Security?

– Use Field-Level Security (rather than creating multiple page layouts) to enforce data security
– Users view data relevant to their job function Troubleshooting Tools
– Field accessibility views
– Setup | Administration Setup | Security Controls | Field Accessibility

Notes:
• Field Level Security is not available in PE
• Field-level security cannot be used to make a field required. This is done from the Page Layout
• Field access settings can be defined using both field-level security and page layouts. However, the most restrictive field access setting of the two will always apply. For example, if a field is required on the page layout, but read-only in the field-level security settings, the field will be read-only.
• Hiding a field from a user using FLS also hides that field from list views, search results, and reports.

(28).  What are Login Hours and Login IP Ranges?

– Sets the hours when users with a particular profile can use the system
– Sets the IP addresses from which users with a particular profile can log in

Notes:
• You can customize profiles to restrict users’ ability to log in to Salesforce.
• You can set the hours when users can log in and the IP addresses from which they can log in.
If a user logs in before the restricted hours, the system will end the user’s session when the restricted hours begin.

Two Options for Restricting Access via IP Ranges
Option 1: Add Trusted IP Ranges for your entire org
Option 2: Add Trusted IP Ranges on a Profile by Profile basis

for more info about http://theblogreaders.com/trusted-ip-ranges-in-salesforce/

(29).  What is a User Record?

– Key information about a user
– Each has its own unique username
– User logs in with username and password
– Users can be active or inactive; an active user uses a license
– Users are associated with a Profile
– Users are usually associated with a Role

(30). What is a Record Owner?

– The user (or queue for Cases and Leads) who controls or has rights to that particular data record
– An Owner has the following special privileges:
• View and edit capabilities
• Transfer capability – change ownership
• Deletion capabilities
– Important assumption: Object permissions enabled
– The Account Owner, Opportunity Owners and Case Owners may or may not be the same user.

31). What are Organization Wide Defaults?

– Defines the baseline level of access to data records for all users in the Organization (not including records owned by the user or inherited via role hierarchy)
– Used to restrict access to data

Access levels:
-Private
-Public Read/Write
-Public Read/Write/Transfer
-Controlled by Parent
-Public Read Only

Organization Wide Defaults

(32). What is a Role and Role Hierarchy?

Role:
– Controls the level of visibility that users have to an organization’s data
– A user may be associated to one role

Role Hierarchy:
– Controls data visibility
– Controls record roll up – forecasting and reporting
– Users inherit the special privileges of data owned by or shared with users below them in the hierarchy
– Not necessarily the company’s organization chart

Notes:
• If using Customizable Forecasting, there is a separate forecast role hierarchy.
• EE can create Account, Contact, Opportunity and Case Sharing Rules. PE can ONLY create Account and Contact Sharing Rules.
• Assuming no sharing rules have been created, users in the same role cannot access one another’s records.
Example: Org Wide Default settings for opportunities are private. Creating a role and adding two users to that role does not allow those users access to one another’s opportunities.
• “Grant Access Using Hierarchies” allows you to disable the default sharing access granted by your role and territory hierarchies. This option can be changed for custom objects that do not have their organization-wide default sharing setting set to Controlled by Parent.

(33). What is Access at the Role Level?

– Defined when creating a role
– Level of access to Opportunities associated to Accounts owned by the role
– Level of access to Contacts associated to Accounts owned by the Role
– Level of access to Cases associated to Accounts owned by the role
– Level of access options depend on OWD

Notes:
• You can create up to 500 roles for your organization
• Every user must be assigned to a role, or their data will not display in opportunity reports, forecast roll-ups, and other displays based on roles
• All users that require visibility to the entire organization should belong to the highest level in the hierarchy
• It is not necessary to create individual roles for each title at your company, rather you want to define a hierarchy of roles to control access of  information entered by users in lower level roles
• When you change a user’s role, any relevant sharing rules are evaluated to add or remove access as necessary

(34). What is a Sharing Rule?

– Automated rules that grant access to groups of users
– Exceptions to Organization Wide Defaults
– Irrelevant for Public Read/Write organizations
– Levels of Access that can be granted
• Read Only
• Read/Write

Notes:
• Sharing rules should be used when a user or group of users needs access to records not granted them by either the role hierarchy setup or the organization wide default settings.
- Sharing rules open up access whereas organization wide defaults restrict access.
- You can use sharing rules to grant wider access to data. You cannot restrict access below your organization-wide default levels.
• Sharing rules apply to all new and existing records owned by the specified role or group members.
• Sharing rules apply to both active and inactive users.
• When you change the access levels for a sharing rule, all existing records are automatically updated to reflect the new access levels.
• When you delete a sharing rule, the sharing access created by that rule is automatically removed.
• When you transfer records from one user to another, the sharing rules are reevaluated to add or remove access to the transferred records as  necessary.
• When you modify which users are in a group or role, the sharing rules are reevaluated to add or remove access as necessary.
• For contact, opportunity and case sharing rules, if the role or group members do not have access to the account associated with the shared contact, opportunity or case the rule automatically gives them access to view the account as well.
• Managers in the role hierarchy are automatically granted the same access that users below them in the hierarchy have from a sharing rule.
• You can edit the access levels for any sharing rule. You cannot change the specified groups or roles for the rule.

(35). Types of Sharing Rules in Salesforce and Explain it?

Account Sharing Rules:
– Based on who owns the account
– Set default sharing access for accounts and their associated cases, contacts, contracts, and opportunities

Contact Sharing Rules:
– Based on who owns the contact (must be associated with an account)
– Set default sharing access for individual contacts and their associated accounts
– Cannot use with: Territory Management and B2I (Person Account) enabled orgs

Opportunity Sharing Rules (EE/UE):
– Based on who owns the opportunity
– Set default sharing access for individual opportunities and their associated accounts

Case Sharing Rules (EE/UE):
– Based on who owns the case
– Set default sharing access for individual cases and associated accounts

Lead Sharing Rules (EE/UE):
– Based on who owns the lead
– Set default sharing access for individual leads

Custom Object Sharing Rules (EE/UE):
– Based on who owns the custom object
– Set default sharing access for individual custom object records

(36). Uses cases for Sharing Rules in salesforce?

– Organizations with organization-wide defaults of Public Read Only or Private can create sharing rules to give specific users access to data owned by other users.
– Cases Sharing Example: To use cases effectively, customer support users must have read access to accounts and contacts. You can create account sharing rules to give your customer support team access to accounts and contacts when working on cases.
– Account Sharing Example: The Western and Eastern Regional Directors need to see all of the accounts created by each others’ sales reps. You can create two public groups – one that includes the Western and Eastern Regional Director roles and one that includes the Western and Eastern Sales Rep roles. Then create an account sharing rule so that records owned by the Western and Eastern Sales Rep group are shared with the group containing the Western and Eastern Regional Director roles.

(37). Best Practices of Creating Contact Sharing Rules?

– Account Org-Wide Default must be set to at least “Public Read Only” in order to set the Contact Org-Wide Default to “Public Read/Write”.
– To share ALL contacts in the system with a group of users or a specific role, create a sharing rule that uses the “All Internal Users” (or “Entire Organization”) public group as the owned by option.
– Use “Roles and Subordinates” over “Roles” where possible to minimize the number of sharing rules.

(38). What is a Public Group?

– A grouping of:
• Users
• Public Groups (nesting)
• Roles
• Roles and Subordinates
– Mixture of any of these elements
– Used in Sharing Rules – for simplification (when more than a few roles need to be shared to)
– Also used when defining access to Folders and List Views

For example, if a new user is assigned a role that belongs to an existing public group, that user will be
automatically added to the public group

(39). What is Manual Sharing?

– Granting record access, one-off basis
– Owner, anyone above owner in role hierarchy and administrator can manually share records
– Available on Contacts, Leads, Cases, Accounts and Opportunity records and Custom Objects
– Like sharing rules, irrelevant for Public Read/Write organizations

(40). What is a Sales Team? (EE/UE)

– Used for collaborative selling
– Used for sharing as well as reporting purposes
– Ad hoc or may use Default Sales Team (defined for user)
– Default Sales Teams may be automatically added to a user’s opportunities
– Who can add a Sales Team?
• Owner
• Anyone above owner in role hierarchy
• Administrator
Adding Default Sales Team Members:
– Click Setup | My Personal Information | Personal Information

Please note that the Professional Edition does NOT have access to the Team Selling Feature.

(41). Org Wide Defaults Vs Role Hierarchy Vs Sharing Models?

(42). What is an Account Team? (EE/UE)

– Used for collaborative account management
– Used for sharing as well as reporting purposes
– Manually added to Account records
– Default Account Teams may be automatically added to a user’s accounts
– Who can add an account team?
• Owner
• Anyone above owner in role hierarchy
• Administrator

Please note that Account Teams are not available for Professional Edition.

(43). What is an Case Team? (EE/UE)

Case teams enable full communication and collaboration on solving customer issues. You can:
– Add teams of users to cases
– Create a workflow for case teams
– Predefine case teams for users
– Determine the level of access
– Administrators can predefine case teams for users and determine the level of access each team member has to a case, such as Read/Write or Read/Only.
– Click Path: Setup | Customize | Cases | Case Teams

(44). What are Folders?

– Used for organizing email templates, documents, reports and dashboards
– Access is defined – Read or Read/Write
– Access is explicit – does NOT roll up through role hierarchy

Notes:
– You can modify the contents of a folder if the folder access level is set to Read/Write.
– Only users with the “Manage Public Documents” or “Manage Public Templates” can delete or change a Read Only folder.
– The Documents tab does NOT contain version control capabilities
– To search documents, users must use Documents search. The sidebar search does NOT search Documents, Solutions, Products, and Reports but does search Assets and Custom Objects
– The Create New Folder link will only be visible to users with the “Manage Public Documents” permission
– The size limit for documents uploaded is 5MB. The size limit for document filenames is 255 characters including the file extension

(45). What is Workflow?

Salesforce Workflow gives you the ability to automatically:
– Create and send email alerts
– Create and assign tasks
– Update field values to either specific values, or based on formulas
– Create and send outbound API messages
– Create and execute time-dependent actions

Workflow Important Points:
• Your sales organization operates more efficiently with standardized internal procedures and automated business processes – workflow.
• You can set up Salesforce to automatically send email alerts, assign tasks, or update field values based on your organization’s workflow.
• Workflow rules can be used to assign follow-up tasks to a support rep when a case is updated, send sales management an email alert when a sales rep qualifies a large deal, change the owner of a contract when it has been signed by the customer, or trigger an outbound API message to an external HR system to initiate the reimbursement process for an approved expense report.

(46). What are Workflow Components available?

Workflow consists of the following components:
– Workflow Rules – trigger criteria for performing various workflow actions
– Workflow Tasks – action that assigns a task to a targeted user
– Workflow Email Alerts – action that sends an email to targeted recipients
– Workflow Field Updates – action that updates the value of a field automatically
– Workflow Outbound Messages – action that sends a secure configurable API message (in XML format) to a designated listener (not covered in this class)

Notes:
• Workflow Rules use workflow actions when their designated conditions are met. Workflow rules can be triggered any time a record is saved or created, depending on your rule settings. However, rules created after saving records do not trigger those records retroactively.
• Workflow Tasks are like task templates, containing the information a workflow rule uses to assign a task to specified users whenever specific business actions trigger the rule. Workflow tasks provide the Subject, Status, Priority, and Due Date for the tasks a rule assigns.
• Workflow Email Alerts are emails generated by a workflow rule using an email template. The emails are sent to designated recipients, either Salesforce users or others, whenever specific business actions trigger a workflow rule.
• Workflow Field Updates specify the field you want updated and the new value for it. Depending on the type of field, you can choose to apply a specific value, make the value blank, or calculate a value based on a formula you create.
• Workflow Outbound Messages send the information you specify to an endpoint you designate, such as an external service. An outbound message sends the data in the specified fields in the form of a SOAP message to the endpoint.

(47). What is a Workflow Rule?

– Defined trigger criteria based on your business requirements
– Evaluated when record is created, when created/updated, OR when created/updated and did not previously meet trigger criteria
– When trigger criteria is met workflow actions, such as email alerts, tasks, field updates, or outbound messages are generated

To get started using workflow rules, click
• Setup | Create| Workflow & Approvals | Workflow Rules

(48). What is a Workflow Task?

– When a Workflow Rule is met, a Task may be assigned to designated users to follow-up and respond to the Business Conditions in the Workflow Rule
– Workflow Tasks may be assigned to a user, role, record owner, record creator, sales team role, or account team
– Tracked in Activity History and can be reported on
– Can be re-used within the same object
– Tasks can be immediate or time-dependent

To create your workflow tasks:
Click Setup | Customize | Workflow & Approvals | Tasks

(49). What is a Workflow Alert?

– Workflow Alerts are emails generated by a workflow rule whenever specific Business Actions trigger the rule
– Can send alerts to Users, Roles, Customer in a Contact Field, Email Field on Page Layout – please see picklist for options…
– Not tracked in Activity History
– Can be re-used within the same object
– Alerts can be immediate or time-dependent

(50). What is a Workflow Field Update?

– Field updates allow you to automatically change the value of a field to a value you specify
– Depending on the type of field you can:
• apply a specific value
• make the value blank
• calculate a value based on a formula you create
– Field updates can be immediate or time-dependent

To get started using workflow Filed Updates, click

Click Setup | Create | Workflow & Approvals | Field Updates

(51). What is Time-Dependent Workflow?

Time-Dependent Workflow gives you the ability to
– execute time-sensitive actions before or after any date on the record
– perform a series of actions at various points in time
– use the Workflow Queue to manage all pending actions Use Time-Dependent workflow to
– send an email reminder to an account team if a high-value opportunity is still open ten days before the close date
– notify the VP of sales if a high value opportunity close date is fast approaching and it has not been closed
– pro-actively notify support rep if an open case with Platinum Support SLA has not been worked for a period of time and take action before the case  escalates

(52). Working with Time-Dependent workflow

Time Triggers
– are time values relevant to the record and are used to initiate a time-dependent action
Time-Dependent Actions
– are any of the five workflow actions with an associated time-trigger
– are queued whenever a rule is triggered (see next page)
– can be reused in additional workflow rules as long as the object is the same
– are removed from the workflow queue if the corresponding record no longer meets rule trigger criteria.
– are dynamically updated in the workflow queue if the corresponding record field is updated.

(53). Time-Dependent Workflow – Considerations

Maximum of 10 time triggers per rule
Maximum of 40 actions (10 x 4 types) per time trigger, and 80 actions per workflow rule
Workflow default user must be set up before creating time-based rules
Precision limited to hours or days
Cannot convert leads with time-dependent actions in the Workflow Queue
Time triggers cannot be added to or removed from activated workflow rules
Not possible to create a time-dependent action associated to a rule with a trigger type of Every time the record is created or updated

(54). When The Add Time Trigger button is unavailable?

The evaluation criteria is set to Evaluate the rule when a record is: created, and every time it’s edited.
The rule is activated.
The rule is deactivated but has pending actions in the workflow queue.

(55). Time-Dependent Workflow Limitations:

Time triggers don’t support minutes or seconds.
Time triggers can’t reference the following:

• DATE or DATETIME fields containing automatically derived functions, such as TODAY or NOW.
• Formula fields that include related-object merge fields.

You can’t add or remove time triggers if:

• The workflow rule is active.
• The workflow rule is deactivated but has pending actions in the queue.
• The workflow rule evaluation criteria is set to Evaluate the rule when a record is: created, and every time it’s edited.
• The workflow rule is included in a package.

(56). What is Approval Processing?

An approval process is an automated Business Process that your organization can use to approve records in Salesforce
An approval process specifies the:
– Steps necessary for a record to be approved
– Who must approve it at each step
– The actions to take when a record is approved, rejected, or first submitted for approval

(57). Approval Terminology

• Approval Request: An approval request is an email notifying the recipient that a record was submitted for approval and his or her approval is  requested.
• Approval Steps: Approval steps assign approval requests to various users and define the chain of approval for a particular approval process.
– Each approval step specifies the attributes a record must have to advance to that approval step, the user who can approve requests for those records, and whether to allow the delegate of the approver to approve the requests.
– The first approval step in a process also specifies the action to take if a record does not advance to that step.
– Subsequent steps in the process also allow you to specify what happens if an approver rejects the request.
• Assigned Approver: The assigned approver is the user responsible for approving an approval request.
• Initial Submission Actions: are the actions that occur when a user first submits a record for approval.
– For example, an initial submission action can lock the record so that no users can edit it during the approval process.
– Initial submission actions can also include any approval actions such as assigning a task, sending an email, or updating a field.
• Final Approval Actions: are the actions that occur when all approval requests for a record are approved.
– Final approval actions can include any approval actions such as email alerts, field updates, tasks, or outbound messages.
– For example, a final approval action can change the status to “Approved” and send a notification email.
• Final Rejection Actions: are the actions that occur when all approval requests for a record are rejected.
– Final rejection actions can include any approval actions such as email alerts, field updates, tasks, or outbound messages.
– For example, a final rejection action can change the status to “Rejected”, send a notification email, and unlock the record so that users can edit it before resubmitting.
• Record Locking: is the process of preventing users from editing a record regardless of field-level security or sharing settings.
– Records that are pending approval are automatically locked by Salesforce.
– Users must have the “Modify All Data” permission to edit locked records.
– The Initial Submission Actions, Final Approval Actions, and Final Rejection Actions related lists contain a record lock action that you can edit if necessary
• Outbound Messages: send the information you specify to an endpoint you designate.
– You can set up workflow rules and approval processes to send outbound messages to an endpoint as a means of getting information to an external service.

(58). Approval Process Checklist

Use the following checklist to plan your approval process:
– Prepare an Approval Request Email
– Determine the Approval Request Sender
– Determine the Assigned Approver
– Determine the Delegated Approver
– Decide if your approval process needs a filter
– Decide initial submission actions
– Decide if users can approve requests from a wireless device
– Determine if users can edit records that are awaiting approval
– Decide if records should be auto-approved or rejected
– Determine how many levels your process has
– Determine the actions when an approval request is approved or rejected

(59). Jump Start Wizard vs. Standard Wizard

– The Jump Start wizard creates a one-step approval process for you in just a few minutes
– The Standard Wizard is useful for complex approval processes.

Jump Start Wizard
• The jump start wizard is useful for simple approval processes with a single step.
• Use the jump start wizard if you want to create an approval process quickly by allowing Salesforce to automatically choose some default options for you.

Standard Wizard
• The standard wizard is useful for complex approval processes.
• Use it when you want to fine tune the steps in your approval process.
• The standard wizard consists of a setup wizard that allows you to define your process and another setup wizard that allows you to define each step in the process.

(60). Parallel Approval Routing

– Send approval requests to multiple approvers in a single step Wait for approval from all the approvers or wait for approval from any one
– Configure an approval step to request approval from any combination of multiple users and related users
– Configure 25 parallel approvers at each step

(61). Data Validation Rules contain

– A Boolean formula or expression that evaluates the data in one or more fields to either “True” or “False”
– A user defined error message that displays when the rule returns a value of “True”
– Data Validation Rules execute when
– A User Saves a Record
– Before records are imported
– Using the Force.com Data Loader and the Force.com API

Data Validation Rules are enforced on Area Impact
Supported Objects All except Forecasts & Territories
Reporting & Dashboards No impact
API Validation rules enforced via API
Import & Data Loader Validation rules enforced via Import & Data Loader
Lead Convert Validation Rules Enforced – must be turned on in Org
Record Merge Not enforced
Offline & Outlook Editions Validation rules enforced when data is synchronized with server
Salesforce Mobile Validation rules enforced when data is synchronized with server
Web To Case
Web To Lead
Validation rules enforced but no feedback to user
Admin notified of any errors
Self Service Portal Validation rules enforced
Apex Packaging Can be packaged

(62). What is the Import Wizard?

– An easy-to-use multi-step wizard for importing new Accounts, Contacts, Leads, Custom Objects or Solutions
– Can be used for Account, Contact, Lead, Custom Objects or Solutions updates based on matching ID
– Contact and Leads may be updated based on matching email address
– Custom Objects or Solutions may be updated based on Custom
Object names, Solutions titles, Salesforce ID or external ID

What is a CSV file?
– File type required when using the Import Wizard
– Values are separated by commas and each row indicates a record of data

What is a record of data?
– One unique unit of related information
– Row of data in a table or spreadsheet

Standard users can import up to 500 account or contact records per session. Organization-wide imports
(system administrators) are limited to 50,000 accounts, contacts, leads, custom objects, or solutions per
session
• During a lead import, you can choose to enable active or inactive assignment rules and/or trigger workflow rules as part of the import

Import Wizard
– Only imports data. Object and fields must be created first.
– Only available for System Administrators
– Must load parent objects first if lookup fields are included
– Loading for multiple record types requires file chunking

Affected Objects and Functions
– Custom Objects, Accounts, Solutions, Contacts, and Leads

(63). What is External ID?

– Flag on any custom field of type Text, Number or Email
– Available on all objects that support custom fields
– Why is it important?
• Increases Report and API SOQL performance
• Allows customers to use the record ID from an external system like the salesforce ID in Import and the API (new “Upsert” call)
– Import supports External ID field that can be used to load and/or synchronize data sourced in external systems
– Customer System of Record master exists in SAP with an SAP customer number. The External ID field may be used to maintain the SAP number
– Migrating large amounts of data, the External ID field may be used to track migration data and run data validation tests before going live

Example of an External Id flow where the update or insert is determined based on an import flow from a
system of record such as Oracle.
• The value proposition here is that we can de-duplicate not only based on our IDs (which are unknown to an external system), but that we can flag an external id (of type text, email, or number) custom field for the purposes of helping to de-duplicate (ie. Update/Insert = Upsert) during the import process; especially when trying to keep multiple systems synchronized

External ID
– Case INSENSITIVE
– Three ID fields per object
– Custom fields only

(64). Force.com Data Loader – Features

– An easy-to-use wizard interface
– An alternate command line interface
– A batch mode interface with database connectivity
– Support for large files with up to millions of rows
– Drag-and-drop field mapping
– Support for all objects, including custom objects
– Detailed success and error log files in CSV format
– A built-in CSV file viewer
– Platform independence, by virtue of being written in Java®

Force.com Data Loader is an application for the bulk import or export of data.
– Use it to insert, update, delete, or extract, or upsert Salesforce records.
– Force.com Data Loader can move data into or out of any salesforce.com object.

(65). Use the Data Loader when:

– You need to load 50,000 or more records.
– You need to load into an object that is not yet supported by web-based importing.
– You want to schedule regular data loads, such as nightly imports.
– You want to be able to save multiple mapping files for later use.
– You want to export your data for backup purposes.
– Use web-based importing when:
– You are loading fewer than 50,000 records.
– The object you need to import is supported by the web-based import wizards.
– You want to prevent duplicates by uploading records according to account name and site, contact email address, or lead email address.

(66). What is the Recycle Bin?

– Houses deleted data for approximately 30 days
– Data can be recovered during this time period
– Not counted against storage limit

If your organization reaches its Recycle Bin limit, Salesforce automatically removes the oldest records if
they have been in the Recycle Bin for at least two hours.
– You cannot delete a product that is used on an opportunity
– You cannot delete the Standard Price Book or a price book that is on an opportunity.

(67). What is a Standard report and Custom Report?

– Out-of-the-box reports, e.g., Account and Contact Reports
– May be used as a starting point for Custom Reports
– May not be deleted or removed (folder can be hidden)

What is a Custom report?
– Created with your specific criteria
– Saved in the My Personal Folder, Unfiled Public folder or custom folder but not in a Standard Folder
– May be edited or deleted
– Can be searched for in Custom Report search

What is the Report Wizard?
– An easy-to-use, multi-step wizard used to create a custom report
– Number of wizard steps depends on Report Type selected

(68). What is a Tabular Report?

– Provides a simple listing of your data without subtotals
– Examples: Contact mailing list report

(69). What is a Summary Report?

– Provides a listing of data, like a Tabular Report, plus sorting and subtotaling of data
– Example: Report showing all opportunities for current FQ, grouped by Stage

(70). What is a Matrix Report?

– Summarizes data in a grid against horizontal and vertical criteria
– Use this report type for comparing related totals
– Similar to a pivot table in Excel
– Example: Report showing all opportunities for your team for current FQ, subtotaled by Stage and Owner

(71). What are Trend Reports?

– Report on opportunity history data by filtering on “as of” date
– Only monthly “as of” dates – displays the report monthly within the interval selected
– Example: Interval = Current FQ will display 10/1/07, 11/1/07, 12/1/07

(72). What are Charts?

– Graphical representation of data of a single Summary or Matrix Report
– Types: Horizontal Bar, Vertical Bar, Line and Pie
– “Grouped” or “Stacked” charts can be created from Summary reports & Matrix reports

(73). What are Relative Dates?

– Used in Views and Reports for filtering
– Dynamic date range, based on current date
– Examples: This Week, Next Month, Last 90 Days

Available Relative Date Filters (not case sensitive):
• Today
• Yesterday
• Tomorrow
• This Week
• Last Week
• Next Week
• This Month
• Last Month
• Next Month
• Last x Days
• Next x Days
• Quarter
• Year
• Fiscal Quarter
• Fiscal Year

(74). What are Custom Report Types?

– Custom report types allow you to build a framework in the report wizard from which users can create and customize reports.
– You build custom report types off of the relationships (masterdetail and lookup) between objects so that you can:
• Choose which standard and custom objects to display to users creating and customizing reports
• Define the relationships between objects displayed to users creating and customizing reports
• Select which objects’ fields can be used as columns in reports
– Define custom report types to display results from an object with or without its related objects
• See which cases were closed with solutions, and which were not.

(75). What is Conditional Highlighting?

– Set thresholds for report analysis
– 3 conditions maximum per report
– Only apply to summary rows
– Numerical analysis only
– First condition is <; second condition <, third condition >=

• You can use conditional highlighting for summary and matrix reports.
• On the Select Chart and Highlights page of the report wizard, you can choose up to three number ranges and colors to conditionally highlight summary data in your report cells.
• If you do not want to highlight a particular range, choose White as the color for that conditional highlighting

(76). What are Dashboards?

– Visual representations of key business information
– Show information from multiple reports
– Made up of Components
– Use Custom Reports as source (Matrix and Summary)
– Running User determines the level of access to the Dashboard Data
– Refresh can be Scheduled
– Email a Dashboard

(77). Dashboard Components

Chart: Graphical representation of report results
Table: A listing of the top or bottom records from a report
Metric: A single data value – drawn from the Grand Total of a report
Gauge: A single data value – displayed as a point on a defined spectrum – drawn from the Grand Total of a report

(78). What is a Campaign?

– Specific marketing program or marketing tactic
– Builds awareness and generates leads

What is a Campaign Member?
– Lead or contact, who is associated to the Campaign
– Individual who has responded to Campaign

Who has access to Campaigns?
• Any user in your organization can view campaigns, view the advanced campaign setup, or run campaign reports.
• However, only designated Marketing Users with the appropriate user permissions can create, edit, and delete campaigns and configure advanced campaign setup.
• An administrator must select the Marketing User checkbox on a user’s personal information to designate that user as a Marketing User.
• In addition, Marketing Users can import leads and use the campaign import wizards if they also have the Marketing User profile (or the “Import Leads” permission and “Edit” on campaigns).
• Campaigns are included with Enterprise, Unlimited, and Developer Editions, and available for an additional cost with Professional Edition

(79). What is a Lead?

– Prospect that you want to market to
– Captures business card information
– Individual who has expressed interest in your product or service
– Assigned ownership either manually or via Assignment Rule

What is a Contact?
– Individual who is associated to an Account

Lead Conversion
– Lead qualification depends on your business process
– Lead information is mapped to the appropriate business object – Account, Contact or Opportunity
– Existing data check

The system automatically maps standard lead fields to standard account, contact, and opportunity fields
• For custom lead fields, your administrator can specify how they map to custom account, contact, and opportunity fields
• The system assigns the default picklist values for the account, contact, and opportunity when mapping any standard lead picklist fields that are blank. If your organization uses record types, blank values are replaced with the default picklist values of the new record owner.
• If the lead has a record type, the default record type of the new owner is assigned to records created during lead conversion.

What is a Web-to-Lead?
– An online form to capture lead information
– Published on your web site

What is an Email Template?
– Standardized text or HTML
– Enables standard and consistent email messaging

What is an Auto-Response Rule?
– Determines which Email Template to send to leads generated via Web-to-Lead
– Contains Rule Entries that determine criteria for determining Email Template response content

(80). What is a Case?

– A logged issue or problem
• Similar Cases may be grouped using a Hierarchy
– Cases are:
• Manually entered from a phone call or an email
• Automatically create Case from an email (Emailto- Case)
• Automatically captured:
– Web site (Web-to-Case)
– Create a Case functionality in Outlook Edition
– May be assigned either manually or automatically via Assignment Rules
– Associated to Contacts and Accounts

What is a Case Queue?
– A virtual storage bin that can be used to group cases based on criteria such as skill requirements, product categories, customer
types, or service levels
– Users have visibility into the Case Queues to which they are members
– Cases remain in the Queue until they are assigned to or taken by individual users

What is a Case Assignment Rule?
– Determines how Cases are automatically routed to User or Queue
– Contains Rule Entries, pre-defined business rules, that determine Case routing

What is Web-to-Case?
– A web form that is published to a web site
– Customers use to submit inquiries online

What is Email-to-Case?
– Automatically create a case when an email is sent to one of your
company’s email addresses, such as support@theblogreaders.com

What are Auto-Response Rules?
– Determines which Email Template to send to cases generated via Web-to-Case
– Contains Rule Entries that determine criteria for determining Email Template response content

What is an Escalation Rule?
– Automatically escalates an unresolved Case within a certain period of time (age over)
– Based on pre-defined business criteria

What are Business Hours?
– Set the organization’s hours of operation
– Escalation Rule uses to determine when to escalate a Case
– Include business hours in multiple time zones.
– Associate cases with specific time zones
– Escalate cases according to specific time zones

(81). What is a Solution?

– An answer to a common question or problem
– Enables Customer Support users get up to speed quickly
– Enables Support teams to answer questions quickly and consistently
– Customers search for and browse published Solutions to selfassist
– Content-Rich Solutions are an enhancement to the Solution Object which allows solution writers to integrate rich text and
images into their solutions to completely solve a problem

What is a Category?
– Mechanism to organize Solutions
– Solutions may be associated to one or more Categories
– Categories make up a Solution Category tree structure

What are Suggested Solutions?
– The suggested solutions feature displays up to ten relevant solutions that may help users and customers solve a particular case from the case detail page and the Self-Service portal.
• Suggested Solutions can be enabled for the following:
Cases tab
Self Service Portal
Case auto-response rules and emails

(82). What is the Self-Service Portal?

– Authenticated portal
– Provides 24/7 online support
– Contains Public Knowledge Base, Suggested Solutions and Web-to-Case functionality

(83). What is the AppExchange?

– A Website Owned and Operated by salesforce.com
– Enables Partners and Customers to Download & Install
• Custom Apps
• Components
– Dashboards, Reports,
– Documents, Profiles,
– S-Controls…
– Public & Private Sharing
– Free to Post and Download
• Partners May Charge for Services

(84). Difference between Force.com IDE and Sandbox?

The Force.com IDE is a powerful client application for creating, modifying, testing and deploying Force.com applications. Based on the Eclipse platform, it provides a comfortable environment for programmers familiar with integrated development environments, allowing you to code, compile, test, and deploy all from within the IDE itself.

Sandbox	Developer Edition
The salesforce.com Sandbox environment is an exact copy of your salesforce.com instance.	Developer Edition was an edition created for development of integrations and apps, specifically for the AppExchange.
You can copy your live instance to a sandbox environment.	You have to perform manually from sandbox to developer edition.
You can either copy your configuration and data into a sandbox environment or just the configuration.	You cannot copy your configuration or data onto the Developer Edition, but you can customize it to match your instance’s look and feel.

(85). What is Roll up summary field in Salesforce?

Roll up summary field in salesforce calculates the Count, Sum, Min or Max of particular field of any child record. Thus, we can say that Roll up summary field can only be created on Master object.

(86). How many types of the relationship fields available in Salesforce?

There are Four types of the Relationship fields available in Salesforce
1. Master Detail
2. Many to Many
3. Lookup
4. Hierarchical (It is only available on User Object, we cannot create this relationship to other SFDC Objects)

(87). What will happen if the Account is deleted?

If the Account is deleted then Contact, Opportunity will also be deleted from Salesforce.
Contact and Opportunity are related to that Account.

(88). What are the types of email templates available in salesforce.com?

1. Text
2. HTML with Letter Head
3. Custom HTML
4. Visual force

You can create four different types of email templates:

1) Text – All users can create or change text email templates. See Creating Text Email Templates.

2) HTML with letterhead – Administrators and users with the “Edit HTML Templates” permission can create HTML email templates based on a letterhead. See Creating HTML Email Templates.

3) Custom HTML – Administrators and users with the “Edit HTML Templates” permission can create custom HTML email templates without using a letterhead. You must either know HTML or obtain the HTML code to insert in your email template. See Creating Custom HTML Email Templates.

4) Visualforce – Administrators and developers can create templates using Visualforce. Visualforce email templates allow for advanced merging with a recipient’s data, where the content of a template can contain information from multiple records, see Creating Visualforce Email Templates.

(89).Sequence of Salesforce Triggers and Order of Execution

The following is the order of salesforce execution when the you create or update a record,
1) Loads the original record from the database or initializes the record for an upsert statement.
2) Loads the new record field values from the request and overwrites the old values.
If the request came from a standard UI edit page, Salesforce runs system validation to check the record for:
Required values at the layout level and field-definition level
Valid field formats (ex: zip code, country code format)
Maximum field length (ex: mobile number must 10 digits)
Salesforce doesn’t perform system validation in this step when the request comes from other sources, such as an Apex application or a SOAP API call.
3) Run all before triggers.
4) Runs most system validation steps again, such as verifying that all required fields have a non-null value, and runs any user-defined validation rules. The only system validation that Salesforce doesn’t run a second time (when the request comes from a standard UI edit page) is the enforcement of layout-specific rules.
5) Saves the record to the database, but doesn’t commit yet.
6) Run all after triggers.
7) Run assignment rules.
8) Run auto-response rules.
9) Run workflow rules.
10) If there are workflow field updates, updates the record again.
11) If the record was updated with workflow field updates, fires before and after triggers one more time (and only one more time), in addition to standard validations. Custom validation rules are not run again.
12) Run escalation rules.
13) If the record contains a roll-up summary field or is part of a cross-object workflow, performs calculations and updates the roll-up summary field in the parent record. Parent record goes through save procedure.
14) If the parent record is updated, and a grand-parent record contains a roll-up summary field or is part of a cross-object workflow, performs calculations and updates the roll-up summary field in the parent record. Grand-parent record goes through save procedure.
15) Run Criteria Based Sharing evaluation.
16) Commits all DML operations to the database.
17) Run post-commit logic, such as sending email.

(90). How to delete the User from Salesforce?

salesforce does not allow to delete any user, however you can deactivate the users.

You can delete delete the Users Data using Mass Delete Record
Setup-> Administration Setup-> Data Management-> Mass Delete Record, from there select the objects like Account, Contact, Cases, Opportunity, Product etc and in criteria select the users name and delete all records of that user related data in the curresponding object.

(91). How to restrict the user to see any record, lets say CASES?

set up cases sharing to be private.  If both users are admins or have view all records on cases, then that overrides private sharing.

(92).What is difference between WhoId and WhatId in the SFDC Data Model of Task/Events ?

WhoID – Lead ID or a Contact ID
WhatID – Account ID or an Opportunity ID or Custom Object ID

(93). What is Master Detail relationship and look up relationship in Salesforce?

Master Detail relationship is the Parent child relationship. In which Master represents Parent and detail represents Child. If Parent is deleted then Child also gets deleted. Rollup summary fields can only be created on Master records which will calculate the SUM, AVG, MIN of the Child records.

Look up relationship is something like “has-a” (Containership) relationship. Where one record has reference to other records. When one record is deleted then there is no impact on other records.

(94). Can we convert the lookup relationship to Master Detail relationship?

Yes, We can convert the lookup relationship to master detail relationship only if all the existing record has valid lookup field values.

(95). Can we create Master Detail relationship on existing records?

No. first we have to create the lookup relationship then populate the value on all existing record and then convert it.

(96). In How many way we can invoke the Apex class?

1. Visualforce page
2. Trigger
3. Web Services
4. Email Services

(96). What is the custom settings?

Custom settings are similar to custom objects and enable application developers to create custom sets of data, as well as create and associate custom data for an organization, profile, or specific user. All custom settings data is exposed in the application cache, which enables efficient access without the cost of repeated queries to the database. This data can then be used by formula fields, validation rules, Apex, and the Web services API.

(97). Types of the custom settings?

List Custom Settings:
A type of custom setting that provides a reusable set of static data that can be accessed across your organization. If you use a particular set of data frequently within your application, putting that data in a list custom setting streamlines access to it. Data in list settings does not vary with profile or user, but is available organization-wide. Examples of list data include two-letter state abbreviations, international dialing prefixes, and catalog numbers for products. Because the data is cached, access is low-cost and efficient: you don’t have to use SOQL queries that count against your governor limits.
Hierarchy Custom Settings:
A type of custom setting that uses a built-in hierarchical logic that lets you “personalize” settings for specific profiles or users. The hierarchy logic checks the organization, profile, and user settings for the current user and returns the most specific, or “lowest,” value. In the hierarchy, settings for an organization are overridden by profile settings, which, in turn, are overridden by user settings.

Ref: http://wikisf.blogspot.com/