Heroku deploy local jar to Maven Dependencies

Sometime a jar is not available via Maven Central Repository and you need to load a jar from your local filesystem. Copy the jar file to a lib directory in your project.

Execute the following command via command line

mvn deploy:deploy-file -Durl=file:salesforce/lib/ 
-Dfile=salesforce/lib/emp-connector-0.0.1-SNAPSHOT-phat.jar 
-DgroupId=com.salesforce.conduit 
-Dpackaging=jar 
-Dversion=0.0.1-SNAPSHOT 
-DartifactId=emp-connector

Add the following to maven pom.xml

 <repositories>
    <repository>
        <id>project.local</id>
        <name>project</name>
        <url>file:${project.basedir}/lib</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
 </repositories>
 <dependencies>
    <dependency>
        <groupId>com.salesforce.conduit</groupId>
        <artifactId>emp-connector</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

Apex Return Diff fields between records

Sometimes you want to determine what has changed between an existing record in the database and an update to the record. The diffRecord method will return all the fields that changed for a specific record.

Compare the difference between to records and return changed fields

public SObject diffRecord(SObject updatedRecord, SObject currentRecord, String sObjectName){
  SObjectType objToken = Schema.getGlobalDescribe().get(sObjectName);
  DescribeSObjectResult objDef = objToken.getDescribe();
  Map<String, SObjectField> fields = objDef.fields.getMap();
  Type classType = Type.forName(sObjectName);
  SObject diffRecord = (SObject)JSON.deserialize('{}', classType);
  for (String field : fields.keySet()){
    if (!fieldsToExclude.contains(fields.get(field).getDescribe().getName()) && (fields.get(field).getDescribe().isUpdateable() || fields.get(field).getDescribe().isCreateable())){
        if (updatedRecord.get(field)!=currentRecord.get(field))
        	diffRecord.put(field, updatedRecord.get(field));
    }
  }
  return diffRecord;
}

Test that only changed fields are returned

@isTest static void testDiffRecords(){
  String currentRecordJSON = '{"Id":"a0L63000000qc43EAA","Account_Type__c":"Managed","Amount__c":50.00,"Category__c":"Deposit","Description__c":"Deposit","End_Date__c":"2020-03-31T15:06:57.000+0000","Frequency__c":"Monthly"}';
  String updatedRecordJSON = '{"Amount__c":50.0,"Id":"a0L63000000qc43EAA","Frequency__c":"Annually"}';
  Type classType = Type.forName('Account');
  SObject currentRecord = (SObject)JSON.deserialize(currentRecordJSON, classType);
  SObject updatedRecord = (SObject)JSON.deserialize(updatedRecordJSON, classType);
  Test.startTest();
    SObject diffRecord = App_Service.instance.diffRecord(updatedRecord, currentRecord, 'Account');
    System.assertEquals(diffRecord.get('Amount__c'), null);
    System.assertEquals(diffRecord.get('Frequency__c'), 'Annually');
    System.assertEquals(diffRecord.get('Account_Type__c'), null);
    System.assertEquals(diffRecord.get('Category__c'), null);
  Test.stopTest();
}

Apex Compare two Records and Merge updated fields

When you have two record, one being the existing queried record and the other the updated record. To merge the original with the updated field without committing the changes you can iterate the current record’s fields and check which of the fields changed. Update the changed fields to the new updated fields value. Now we have an merged record. Here is how I went about doing it.

Original SObject record

{"Account_Type__c":"Managed","Amount__c":50.00,"Category__c":"Deposit",
"Description__c":"Deposit","End_Date__c":"2020-03-31T15:06:57.000+0000",
"Frequency__c":"Monthly"}

Update SObject record

{"Amount__c":500.0,"Id":"a0L63000000qc43EAA","Frequency__c":"Annually"}

Merge two records with changes

private static Set<String> fieldsToExclude = new Set<String>{'OwnerId','OtherGeocodeAccuracy','MailingGeocodeAccuracy','BillingGeocodeAccuracy','ShippingGeocodeAccuracy'};
public SObject mergeRecords(SObject updatedRecord, SObject currentRecord, String sObjectName){
  SObjectType objToken = Schema.getGlobalDescribe().get(sObjectName);
  DescribeSObjectResult objDef = objToken.getDescribe();
  Map<String, SObjectField> fields = objDef.fields.getMap();
  Type classType = Type.forName(sObjectName);
  SObject mergedRecord = (SObject)JSON.deserialize('{}', classType);
  for (String field : fields.keySet()){
    if (!fieldsToExclude.contains(fields.get(field).getDescribe().getName()) && (fields.get(field).getDescribe().isUpdateable() || fields.get(field).getDescribe().isCreateable())){
        if (updatedRecord.get(field)!=null){
        	mergedRecord.put(field, updatedRecord.get(field));
    	} else if (currentRecord.get(field)!=null){
        	mergedRecord.put(field, currentRecord.get(field));
    	}
    }
  }
  return mergedRecord;
}

Test that fields were merged correctly

@isTest static void testMergeRecords(){
  String currentRecordJSON = '{"Id":"a0L63000000qc43EAA","Account_Type__c":"Managed","Amount__c":50.00,"Category__c":"Deposit","Description__c":"Deposit","End_Date__c":"2020-03-31T15:06:57.000+0000","Frequency__c":"Monthly"}';
  String updatedRecordJSON = '{"Amount__c":500.0,"Id":"a0L63000000qc43EAA","Frequency__c":"Annually"}';
  Type classType = Type.forName('Account');
  SObject currentRecord = (SObject)JSON.deserialize(currentRecordJSON, classType);
  SObject updatedRecord = (SObject)JSON.deserialize(updatedRecordJSON, classType);
  Test.startTest();
    SObject mergedRecord = mergeRecords(updatedRecord, currentRecord, 'Account');
    System.assertEquals(mergedRecord.get('Amount__c'), 500.0);
    System.assertEquals(mergedRecord.get('Frequency__c'), 'Annually');
    System.assertEquals(mergedRecord.get('Account_Type__c'), 'Managed');
    System.assertEquals(mergedRecord.get('Category__c'), 'Deposit');
  Test.stopTest();
}

Apex fflib_SObjectUnitOfWork SimpleDML UNABLE_TO_LOCK_ROW nested try catch

UNABLE_TO_LOCK_ROW issue is very common if you have multiple users updating the record at the same time .Or say a batch job is running and is updating a record and same record another trigger or code snippet (usually a future method) is updating. A way to solve this is to retry multiple times to see if the record has been unlocked for update.

Multi-try will try update 3 times before throwing and error

public class SimpleDML implements IDML
{
	public void dmlUpdate(List<SObject> objList){
		try {
			update objList;
		} catch (System.DMLException ex1){
			if (StatusCode.UNABLE_TO_LOCK_ROW==ex1.getDmlType(0)){
				try{
					update objList;
				} catch (System.DMLException ex2) {
					if (StatusCode.UNABLE_TO_LOCK_ROW==ex2.getDmlType(0)){
						update objList;
					} else {
						throw ex2;
					}
				}
			} else {
				throw ex1;
			}
		}
	}
}

Apex Caching Performance Impact

Apex Caching is great for saving some basic Id’s of a user like his Account, Contact Id’s after he logs in so you don’t have to query for them. Reduces the amount of queries and improves speed. Caching is good for saving large blobs that don’t change frequently.

Generic Cache Service to put, retrieve and remove cached item

public with sharing class App_Service_Cache {

		private Boolean cacheEnabled;

		public App_Service_Cache() {
			  cacheEnabled = true;
		}

    public Boolean toggleEnabled() { // Use for testing misses
        cacheEnabled = !cacheEnabled;
        return cacheEnabled;
    }

    public Object get(String key) {
        if (!cacheEnabled) return null;
        Object value = Cache.Session.get(key);
        if (value != null) System.debug(LoggingLevel.DEBUG, 'Hit for key ' + key);
        return value;
    }

    public void put(String key, Object value, Integer ttl) {
        if (!cacheEnabled) return;
        Cache.Session.put(key, value, ttl);
        // for redundancy, save to DB
        System.debug(LoggingLevel.DEBUG, 'put() for key ' + key);
    }

    public Boolean remove(String key) {
        if (!cacheEnabled) return false;
        Boolean removed = Cache.Session.remove(key);
        if (removed) {
            System.debug(LoggingLevel.DEBUG, 'Removed key ' + key);
            return true;
        } else return false;
    }
}

Test cache get is faster than query

@isTest
private class App_Service_Cache_Test {

	@isTest
	static void testCachePerformance() {
		App_Service_Cache appCache = new App_Service_Cache();
		Map<String, String> communityUser = App_Global_Test.setupCommunityUserReturnIds();
		Id userId = communityUser.get('UserId');
		long startTime = System.currentTimeMillis();
		List<Contact> currentContact = [select Id, AccountId from Contact where Id IN (Select ContactId from User where Id=:userId)];
		long elapsedTime = System.currentTimeMillis() - startTime;
		appCache.put('userId', currentContact, 2000);
		System.debug(elapsedTime);

		long startCacheTime = System.currentTimeMillis();
		appCache.get('userId');
		long elapsedCacheTime = System.currentTimeMillis() - startCacheTime;
		System.assert(elapsedCacheTime < elapsedTime);
	}
}

Create a Salesforce EventBus

Create a new Planform Event Object and give it a name App Metadata (App_Metadata__e) which will also be the name of the topic. Create some fields you that you would like to listen to. In Apex add the following event

Build event payload

  List<App_Metadata.BPUpdateAccounts> updatedAccountList = new List<App_Metadata.BPUpdateAccounts>();
  App_Metadata.BPUpdateAccounts updatedAccount = new App_Metadata.BPUpdateAccounts();
  updatedAccount.setId(financialAccount.Id);
  updatedAccount.add(updatedAccount);
  new App_Rest_Events(new App_Rest_Events.Event(UserInfo.getUserId(), App_Rest_Events.EventType.UPDATE_ACCOUNT, 
  updatedAccountList)).publishToEventBus();

Publish Event to eventBus

  public void publishToEventBus(){
    Object eventPayload = buildEventPayload();
    EventBus.publish(new App_Metadata__e(Metadata_Json__c=JSON.serialize(eventPayload)));
  }

Now let’s create our event listen to subscript to the topic and consume the messages from the EventBus.

Add the emp-connector jar to project

<repositories>
        <repository>
            <id>emp-connector</id>
            <url>${project.basedir}/lib/emp-connector-0.0.1-SNAPSHOT-phat.jar</url>
        </repository>
    </repositories>

....

<dependency>
     <groupId>com.salesforce.conduit</groupId>
     <artifactId>emp-connector</artifactId>
     <version>0.0.1-SNAPSHOT</version>
</dependency>

Create TopicSubscription to your event table by name

package com.app.salesforce.eventbus;

import com.salesforce.emp.connector.BayeuxParameters;
import com.salesforce.emp.connector.EmpConnector;
import com.salesforce.emp.connector.TopicSubscription;

import java.net.URL;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

import static com.salesforce.emp.connector.LoginHelper.login;

/**
 * Created by thysmichels on 5/15/17.
 */
public class SalesforceEventBus {

    private static final String SALESFORCE_USERNAME="salesforceUsername";
    private static final String SALESFORCE_PASSWORD="salesforcePassword";

    public static void main(String[] argv) throws Exception {

        long replayFrom = EmpConnector.REPLAY_FROM_EARLIEST;

        BayeuxParameters params;
        BayeuxParameters custom = getBayeuxParamWithSpecifiedAPIVersion("39.0");
        try {
            params = login(new URL("https://test.salesforce.com"),SALESFORCE_USERNAME, SALESFORCE_PASSWORD, custom);

        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(1);
            throw e;
        }

        Consumer<Map<String, Object>> consumer = event -> System.out.println(String.format("Received:\n%s", event));
        EmpConnector connector = new EmpConnector(params);

        connector.start().get(5, TimeUnit.SECONDS);

        TopicSubscription subscription = connector.subscribe("/event/App_Metadata__e", replayFrom, consumer).get(5, TimeUnit.SECONDS);

        System.out.println(String.format("Subscribed: %s", subscription));
    }


    private static BayeuxParameters getBayeuxParamWithSpecifiedAPIVersion(String apiVersion) {
        BayeuxParameters params = new BayeuxParameters() {

            @Override
            public String version() {
                return apiVersion;
            }

            @Override
            public String bearerToken() {
                return null;
            }

        };
        return  params;
    }
}

Topic receives response from subscribed channel

Subscribed: Subscription [/event/App_Metadata__e:-2]
Received:
{schema=D6-eSgLDrahnNjuNI52XAg, payload={CreatedById=00521000000UcF0, CreatedDate=2017-05-15T18:35:10Z, 
Metadata_Json__c="{\"accounts\":[{\"id\":\"28706236\",\"providerAccountId\":14736,\"sfId\":\"a0721000001A6fOAAS\"},
{\"id\":\"YL1111\",\"providerAccountId\":1466,\"sfId\":\"a0721000001A6fPAAS\"}],\"event\":\"UPDATE_GOAL\",\"linkAccounts\":null,
\"financialAccountMap\":null,\"goals\":[{\"id\":\"a0821000000OVPUAA4\",\"linkedAccounts\":[\"a0721000001ADqkAAG\"],
\"status\":\"In Progress\"},{\"id\":\"a0821000000OVPZAA4\",\"linkedAccounts\":null,\"status\":\"In Progress\"},{\"id\":\"a0821000000OVPeAAO\",\"linkedAccounts\":[\"a0721000001ADqaAAG\"],\"status\":\"In Progress\"}],
\"linkUserContext\":{\"accountList\":null,\"additionalProperties\":null,\"deleteAccountList\":null,\"email\":\"blah@email.com\",
\"password\":\"p@assw0rd\",
\"providerAccountIds\":null,\"sfClientId\":\"0033600000NO1QjAAL\",\"sfHouseholdId\":\"0013600000VNXflAAH\",\"sfUserId\":\"00521000000UcF0AAK\",
\"type\":\"YL\",\"username\":\"YL00F0A\"},\"priority\":5,\"providerAccounts\":null,
\"updatedAccounts\":null,\"updatedGoals\":[{\"id\":\"a0821000000OVPZAA4\",\"linkedAccounts\":null}],\"mapKeys\":{\"event\":\"event\",\"priority\":\"priority\",\"linkUserContext\":\"linkUserContext\",\"goals\":\"goals\",
\"accounts\":\"accounts\",\"providerAccounts\":\"providerAccounts\",\"updatedAccounts\":\"updatedAccounts\",\"updatedGoals\":
\"updatedGoals\",\"goalFinancialAccountMap\":\"goalFinancialAccountMap\",\"fastlinkAccounts\":\"fastlinkAccounts\"},
\"mapKeysFlag\":true,\"serializeNulls\":false}"}, event={replayId=1}}

Apex One Endpoint to Rule them all

Most systems need to do CRUD on some objects and also query some information. Why not have one endpoint to do it all?I have created a endpoint that can do all that using mapping between systems field and Salesforce fields. System field does not contain any underscores or Salesforce specific syntax like (__c). With that a system can send:

{“name”:”John Doe”, “taxRatePerClient”:20}

And it will be translated to:

{“Name”:”John Doe”, “Tax_Rate_Per_Client__c”:20}

Do CRUD and execute any query

global with sharing class App_Rest_Data {

	global with sharing class Post implements App_Rest_Dispatcher.Dispatchable {
		private App_Rest_Global_Request_Json requestBody;

		global String getURIMapping(){
						return App_Rest_Constants.URI_DATA +'/{object}/{operation}';
		}

		global void setRequestBody(App_Rest_Global_Request_Json requestBody){
				this.requestBody = requestBody;
		}

		global App_Rest_Global_Json execute(Map<String, String> parameters){
			App_Rest_Global_Json globalJson = new App_Rest_Global_Json();
			String objectName = parameters.get('object');
			String operation = parameters.get('operation');

			if ('q'.equals(operation)){
				globalJson.setResult(Database.query(String.valueOf(((Map<String, Object>)JSON.deserializeUntyped(requestBody.getRequest())).get('query'))));
			} else {
	            Map<String,String> uiFieldNamesForObject = App_Rest_Settings.getModelByObject(objectName);
	            App_JSON.DynamicModel dynamicModel = new App_JSON.DynamicModel(uiFieldNamesForObject);
	            dynamicModel.setMapKeysFlag(true);
	            Type classType = Type.forName(objectName);
	            SObject sobjectModel = (SObject) classType.newInstance();
	            sobjectModel =  (SObject)dynamicModel.deserialize(requestBody.getRequest(), classType);

	            fflib_ISObjectUnitOfWork uow = App_Rest_App.UnitOfWork.newInstance();

	            if ('c'.equals(operation)){
	              uow.registerNew(sobjectModel);
	            } else if ('u'.equals(operation)){
	              uow.registerDirty(sobjectModel);
	            } else if('d'.equals(operation)){
	              uow.registerDeleted(sobjectModel);
	            }
	            uow.commitWork();

	            Schema.SObjectType sobjectModelType = Schema.getGlobalDescribe().get(objectName);
	            fflib_QueryFactory queryFactory = new fflib_QueryFactory(sobjectModelType);
	            queryFactory.selectFields(uiFieldNamesForObject.keySet());

	            globalJson.setResult((List<Object>) Database.query(queryFactory.toSOQL()));
  			}

			return globalJson;
		}

		global override String toString(){
			App_Rest_Endpoint.Path path = new App_Rest_Endpoint.Path();
			path.setPath(getURIMapping());
			App_Rest_Endpoint endpoint = new App_Rest_Endpoint(path);
			return JSON.serialize(endpoint);
		}
	}
}

Testing out CRUD and query operations

@isTest
private class App_Rest_Data_Test {

	@isTest(SeeAllData=true) static void testPost() {
		Test.setMock(HttpCalloutMock.class, new App_LogEntries_Api_Mock());
		RestRequest req = new RestRequest();
		RestResponse res = new RestResponse();
		User communityUser = App_Global_Test.setupCommunityUserAndLogin();
		Test.startTest();
			req.requestBody =  Blob.valueOf('{"firstName":"Test FirstName","lastName":"Test LastName", "email":"test@mail.com"}');
			req.requestURI = '/v1/data/contact/c';
			req.httpMethod = 'POST';
			RestContext.request = req;
			RestContext.response = res;
			App_Rest_Dispatcher.doPost();
		Test.stopTest();

		System.assert(res.responseBody!=null);
		System.assertEquals(res.statusCode, 200);
	}

	@isTest(SeeAllData=true) static void testPatch() {
		Test.setMock(HttpCalloutMock.class, new App_LogEntries_Api_Mock());
		RestRequest req = new RestRequest();
		RestResponse res = new RestResponse();
		User communityUser = App_Global_Test.setupCommunityUserAndLogin();
		Test.startTest();
			Account setupAccount = App_Global_Test.setupAccount();
			req.requestBody =  Blob.valueOf('{"id":"'+setupAccount.Id+'","name":"Test Update"}');
			req.requestURI = '/v1/data/account/u';
			req.httpMethod = 'POST';
			RestContext.request = req;
			RestContext.response = res;
			App_Rest_Dispatcher.doPost();
		Test.stopTest();

		System.assert(res.responseBody!=null);
		System.assertEquals(res.statusCode, 200);
	}

	@isTest(SeeAllData=true) static void testDelete() {
		Test.setMock(HttpCalloutMock.class, new App_LogEntries_Api_Mock());
		RestRequest req = new RestRequest();
		RestResponse res = new RestResponse();
		User communityUser = App_Global_Test.setupCommunityUserAndLogin();
		Test.startTest();
			Account setupAccount = App_Global_Test.setupAccount();
			req.requestBody =  Blob.valueOf('{"id":"'+setupAccount.Id+'","name":"Test Update"}');
			req.requestURI = '/v1/data/account/d';
			req.httpMethod = 'POST';
			RestContext.request = req;
			RestContext.response = res;
			App_Rest_Dispatcher.doPost();
		Test.stopTest();

		System.assert(res.responseBody!=null);
		System.assertEquals(res.statusCode, 200);
	}

	@isTest(SeeAllData=true) static void testQuery() {
		Test.setMock(HttpCalloutMock.class, new App_LogEntries_Api_Mock());
		RestRequest req = new RestRequest();
		RestResponse res = new RestResponse();
		User communityUser = App_Global_Test.setupCommunityUserAndLogin();
		Test.startTest();
			Account setupAccount = App_Global_Test.setupAccount();
			req.requestBody =  Blob.valueOf('{"query":"Select id from User"}');
			req.requestURI = '/v1/data/account/q';
			req.httpMethod = 'POST';
			RestContext.request = req;
			RestContext.response = res;
			App_Rest_Dispatcher.doPost();
		Test.stopTest();

		System.assert(res.responseBody!=null);
		System.assertEquals(res.statusCode, 200);
	}
}

Apex Convert String To Camel Case

Convert string to camelCase for one underscore

   public static String toCamelCase(String input) {
      Pattern p = Pattern.compile('_([a-zA-Z])');
      Matcher m = p.matcher( input );
      fflib_StringBuilder sb = new fflib_StringBuilder();
      while (m.find()) {
          sb.add(m.replaceAll(m.group(1).toUpperCase()));
      }
      return sb.toString().uncapitalize();
     }

Convert string to camelCase for multiple underscore

 public static String toCamelCase(String input){
      fflib_StringBuilder sb = new fflib_StringBuilder();
      boolean capitalizeNext = false;
      for (String c:input.split('')) {
        if (c == '_') {
          capitalizeNext = true;
        } else {
          if (capitalizeNext) {
            sb.add(c.toUpperCase());
            capitalizeNext = false;
          } else {
            sb.add(c.toLowerCase());
          }
        }
      }
      return sb.toString();
    }

To Camel Case Test Class

@isTest
	static void testToCamelCase(){
		Test.startTest();
			System.assertEquals(BrightPlan_Rest_Util.toCamelCase('loan_id'), 'loanId');
			System.assertEquals(BrightPlan_Rest_Util.toCamelCase('Camel_case_This_word'), 'camelCaseThisWord');
			System.assertEquals(BrightPlan_Rest_Util.toCamelCase('this_IS_A_TEst_for_CAMEL_Case'), 'thisIsATestForCamelCase');
		Test.stopTest();
	}

Query Multi-Select Picklists in SOQL

Create list of values to check for multi picklist

       Set<String> typeSet = new Set<String>();
       String allStr = 'All';
       typeSet.add('\''+ allStr + '\'');
       for (Financial_Goal__c goal  : Contact.FinancialGoals__r){
         typeSet.add('\''+ goal.Type__c + '\'');
       }

Query using INCLUDES and using String.join to create string of List.

List<Content__c> typeMappings = (List<Content__c>) Database.query(
contentMappingQueryFactory.setCondition('Status__c=\'Publish\'
AND Id!=:featureMappingId AND (Goal_Type_Attribute__c INCLUDES(' + String.join(goalTypeList, ',')+ ') 
AND Age_Attribute__c INCLUDES(' + String.join(ageList, ',')+ ') 
AND Employment_Attribute__c IN :employementList AND Gender_Attribute__c IN :genderList 
AND Net_Worth_Attribute__c IN :netWorthList)').setLimit(2).toSOQL());

Use , for OR and ; for AND to match values in picklist

OR:
will match for any value in picklist
String.join(goalTypeList, ',')

AND:
will match for all the value in picklist
String.join(goalTypeList, ';')
%d bloggers like this: