The concept of any-org development is an interesting one. The strict definition, to my mind, being the development of a set of components (perhaps packaged) that are designed and coded specifically to install and function in any Salesforce org. This is typically an ISV concern, where testing and maintaining a single-code base can be highly desirable over managing a base package plus multiple extension packages, or in the worse case multiple independent packages. Either way an ISV needs to maximise the addressable market for a product whilst minimising the ongoing effort to do so. The same drivers do not apply in the single-org case, where a consultancy and/or in-house team are delivering technical components to be installed into a known Salesforce org (or multi-org estate). In the single-org case it is common practice to see technical components designed and coded for the current state of the target org(s), with no consideration to how the org(s) may evolve over time. This can often result in situations where costly technical work is required simply to activate an optional product feature, or to provide user access in another locale. In such cases the situation can often be compounded by the fact that the original development team are no longer available.
In short, in my view some degree of future-proofing should be considered in designing for the single-org model, using the techniques applied by ISVs in the any-org model.
Any-org Design Considerations
- Optional Features
Examples; Person Accounts, Quotes
There are a multitude of optional product features which can be enabled directly in the Salesforce web application UI or via Salesforce support. In the majority of cases such feature activations irreversibly add new objects and fields to the Salesforce instance. From the perspective of keeping simple orgs uncluttered by objects related to unused features this makes perfect sense. From the perspective of designing for the any-org model, this approach poses a few challenges. The main challenge being that Apex code won’t compile where a static reference exists to an object (or field) that doesn’t exist in the org. There is no simple answer to this, instead a selective approach should be taken where optional features that may already be active (or could in the future be activated), that have some impact on your code are accommodated. The approach to achieving this for any-org Apex code basically involves replacing static references with Dynamic SOQL and Dynamic Apex (see coding techniques below).
- Multi-currency
The default currency mode of a Salesforce org is single currency, the majority stay this way. It is however common to have multi-currency and perhaps advanced currency management (ACM) activated in orgs where business operations are international. Activation of multi-currency often occurs once the Salesforce org has become established, perhaps in a single region. This can be problematic where technical customisations have been added that aren’t currency aware.
In the any-org case, all Apex code should be multi-currency aware and use Dynamic SOQL to add the CurrencyIsoCode field to all object queries involving currency fields. Additionally, currency aware logic should include checks to ensure that related transactions are the same currency, and that custom analytics are presenting data in the corporate currency (default and therefore expected behaviour for the native reporting functions). Note, the behaviour of aggregate functions involving currency fields must also be handled.
- Editions Support
A key design decision for ISVs is the Salesforce editions to be supported by their managed package. This one has less relevance to the single-org model, unless the multi-org estate includes different editions.
It is possible to group editions into two distinct groups;
1. Group (or Team) Edition and Professional Edition
2. Enterprise Edition and Unlimited Edition
In the case of group 1 assume that standard objects such as Product, Pricebook2, PricebookEntry, RecordType do not exist and ensure no static references exist in the code. The OrganizationType field on the Organization object tells us which edition the code is executing within.
[sourcecode language=”java”]
public static Boolean isTeamOrProEdition(){
if (isTeamOrProEdition==null){
List<Organization> orgs = [select OrganizationType from Organization where Id=:UserInfo.getOrganizationId() limit 1];
if (orgs.size()>0)
isTeamOrProEdition=(orgs[0].OrganizationType==’Team Edition’ || orgs[0].OrganizationType==’Professional Edition’);
}
return isTeamOrProEdition;
}
[/sourcecode]
- Internationalisation
Whether an international user base is anticipated or not it is general software development best practice to externalise string literals into resource files. In the Salesforce context this means Custom Labels. A best practice here is to apply strict categorisation and a meaningful naming convention. Also ensure all literals are externalised not just labels in the UI, for example trigger error messages.
Another consideration for i18n is the use of currency and date formatting helpers. Where UI components do not apply default formatting for an SObject field you need to handle this in code. An i18nHelper class which translates ISO locale and currency codes to date format strings and currency format strings plus symbols respectively can be very helpful.
Useful abbreviations:
i18n – internationalisation; development practice enabling support for localisation.
l11n – localisation; act of localising an internationalised software product for a specific locale.
- Profile Permissions
Visualforce pages are preprocessed for components directly bound to SObject fields where the user profile does not have CRUD or FLS permissions. In such cases the fields are not displayed or are made read-only, depending on visibility state. This comes as a surprise for many developers who assume that User Profile permissions are entirely ignored on Visualforce pages.
reference: Enforcing_CRUD_and_FLS
In the any-org model, where direct SObject field binding is being used in a Visualforce page, this may require a manual check during initialisation to protect the functional integrity of the page. For example, a custom page with no fields displayed and no explanation is not a great user experience, instead the page should simply inform the user they don’t have sufficient permissions, they can then take this up with their Administrators.
[sourcecode language=”java”]
private Boolean hasRequiredFLS(){
// rule 1: all custom fields must be accessible.
// rule 2: check isUpdateable on all fields where inline editing offered.
Schema.DescribeFieldResult d;
Map<String, Schema.SObjectField> siFieldNameToToken=Schema.SObjectType.SalesInvoice__c.fields.getMap();
for (Schema.SObjectField f : siFieldNameToToken.values()){
d = f.getDescribe();
if (!d.isCustom()) continue;
if (!d.isAccessible()) return false;
}
d = siFieldNameToToken.get(‘InvoiceDate__c’).getDescribe();
if (!d.isUpdateable())
this.isInlineEditable=false;
else {
d = siFieldNameToToken.get(‘DueDate__c’).getDescribe();
if (!d.isUpdateable())
this.isInlineEditable=false;
else this.isInlineEditable=true;
}
return true;
}
[/sourcecode]
Coding Techniques
- Dynamic SOQL
Do not statically reference objects or fields that may not exist in the org. Instead compose Dynamic SOQL queries and execute via Database.query(). With this approach, you can build the required query using flags which indicate the presence of optional feature fields such as RecordTypeId, CurrencyIsoCode etc. The Apex Language Reference provides good coverage of Dynamic SOQL. Be very careful to ensure that your composed string does not include user supplied text input – this would open up a vulnerability to SOQL injection security vectors.
[sourcecode language=”java”]
public static Id getStandardPricebookId(){
if (standardPricebookId==null){
String q=’select Id, isActive from Pricebook2 where IsStandard=true’;
SObject p = Database.query(q);
if (!(Boolean)p.get(‘IsActive’)){
p.put(‘IsActive’,true);
update p;
}
standardPricebookId=(String)p.get(‘Id’);
}
return standardPricebookId;
}
public SalesInvoice__c retrieveSalesInvoice(String siId){
try{
//& Using dynamic Apex to retrieve fields from the fieldset to create a soql query that returns all fields required by the view.
String q=’select Id,Name,OwnerId’;
q+=’,TotalGross__c’;
for(Schema.FieldSetMember f : SObjectType.SalesInvoice__c.FieldSets.invoices__Additional_Information.getFields()){
if (!q.contains(f.getFieldPath())) q+=’,’+f.getFieldPath();
}
if (UserInfo.isMultiCurrencyOrganization()) q+=’,CurrencyIsoCode’;
if (AppHelper.isPersonAccountsEnabled()) q+=’,PersonEmail,PersonContactId’;
q+=’,(select Id,Description__c,Quantity__c from SalesInvoiceLineItems__r order by CreatedDate asc)’;
q+=’ from SalesInvoice__c’;
q+=’ where Id=\”+siId+’\”;
return Database.query(q);
} catch (Exception e){
throw e;
}
}
[/sourcecode]
- Dynamic Apex
Do not statically reference objects or fields that may not exist in the org. Instead use Dynamic Apex techniques such as global describes and field describes. Where a new SObject is required, use the newSObject() method as shown below, this is particularly useful for unit test data creation. The Apex Language Reference provides good coverage of Dynamic Apex, every developer should be familiar with this topic.
[sourcecode language=”java”]
public static List<SObject> createPBE(Id pricebookId, List<SObject> products){
SObject pbe;
List<SObject> entries = new List<SObject>();
Schema.SObjectType targetType = Schema.getGlobalDescribe().get(‘PricebookEntry’);
if (targetType==null) return null;
for (SObject p : products){
pbe = targetType.newSObject();
pbe.put(‘Pricebook2Id’,pricebookId);
pbe.put(‘Product2Id’,p.Id);
pbe.put(‘UseStandardPrice’,false);
pbe.put(‘UnitPrice’,100);
pbe.put(‘IsActive’,true);
entries.add(pbe);
}
if (entries.size()>0) insert entries;
return entries;
}
[/sourcecode]
- UserInfo Methods
The UserInfo standard class provides some highly useful methods for any-org coding such as;
isMultiCurrencyOrganization(), getDefaultCurrency(), getLocale() and getTimezone(). The isMultiCurrencyOrganization() method will be frequently used to branch code specific to multi-currency orgs.
[sourcecode language=”java”]
public static String getCorporateCurrency(){
if (corporateCurrencyIsoCode==null){
corporateCurrencyIsoCode=UserInfo.getDefaultCurrency();
if (UserInfo.isMultiCurrencyOrganization()){
String q=’select IsoCode, ConversionRate from CurrencyType where IsActive=true and IsCorporate=true’;
List<SObject> currencies = Database.query(q);
if (currencies.size()>0)
corporateCurrencyIsoCode=(String)currencies[0].get(‘ISOCode’);
}
return corporateCurrencyIsoCode;
}
}
[/sourcecode]
Challenges
- Unit Test Data
In the any-org model the creation of unit test data can be a challenge due to the potential existence of mandatory custom fields and/or validation rules. To mitigate the former, Dynamic Apex can be used to identify mandatory fields and their data type such that test data can be added (via a factory pattern of some sort). In the latter case there is no way to reliably detect a validation rule condition and as such for ISVs it is a blessing that unit tests do not actual have to pass in a subscriber org (wrong as this may be in principle). In the single-org case we can improve on this (and we have to), by adding a global Validation Rule switch-off flag in a Org Behaviour Custom Setting (see previous post) – this approach is helpful in many areas but for unit test data creation it can isolate test code from Validation Rules added post-deployment. There’s a tradeoff here between protecting unit tests versus the risk of using test data that may not adhere to the current set of Validation Rules.
- Unit Test Code Coverage
The addition of multiple conditional code paths, i.e. branching, for the any-org case makes it challenging to achieve a high code coverage percentage in orgs which do not have the accommodated features activated. For example, unit tests executing in a single currency org, will not be run code specific to multi-currency, and therefore the code coverage drops accordingly. To mitigate this, consider adding OR conditions to IF branches which include unit test flags and perhaps Test.isRunningTest() to cover as much code as possible before leaving the branch. During coding always strive to absolutely minimise the feature-specific code – this approach will help greatly in respect to unit test coverage.
- QA
In the any-org model, it is imperative to test your code in an org with the accommodated features activated. This will require multiple QA orgs and can increase the overall testing overhead considerably. Also, factor in the lead time required to have features activated by Salesforce support, such as multi-currency and Person Accounts.
- Security
Dynamic SOQL queries open up the possibility of SOQL-injection attacks where user-supplied text values are concatentated into an executed SOQL query string. Always sanitise and escape data values where such code behaviour is necessary.
- Governor Limits
The any-org model is highly contingent upon the use of limited resources such as Apex Describes. As a best practice employ a helper class pattern with cached values.
One Approach – Future Proofing Single-org Developments
Optional Features – selective
Multi-currency – yes
Editions Support – no
i18n – yes
Unit Test Data – yes
Profile Permissions – yes
The list above is my default position on the approach to take on single-org developments, this can change significantly depending on the current state of the org in terms of configuration and customisation, plus the client perspective on the evolution of their Salesforce org and attitude toward investing in future-proofing/extensibility. In the single-org, consultancy project case it’s advisable to be completely open and let the client decide if the additional X% cost is worth the value. I think the real point here is that the conversation takes place and the client has the opportunity to make an informed decision.
