Sonoma Partners Microsoft CRM and Salesforce Blog

Remain DRY by checking your @testSetup

Among the many exciting features of the upcoming Spring ’15 release there is a hidden gem for developers coming: the new @testSetup annotation. This new annotation will let you refactor chunks of code common to each test within a test class in to a common setup method that is guaranteed to be called before each test method is run. When combined with a Factory pattern to actually do the creation of test data and settings, this becomes a powerful way to organize your code so that it is easy to read and understand, and consistent across projects.

Trying to remain DRY

Historically, unit tests have been a difficult place for developers to remain DRY. There are several solutions for this, but most get ignored or are underutilized due to the overriding need for unit tests to be exceptionally readable. Testing software is notoriously difficult, and anything that attempts this in an automated fashion needs to be simpler, more readable and more maintainable than the software it is testing – otherwise you may need to start testing the tests! Generally, the lack of patterns and desire to remain simple and readable leads to the opposite of what we would want in any other part of our code base: repeated code. It’s not uncommon to see code like the following, with repeated setup code at the beginning of each test method:

Oftentimes, developers will see this repeated code and attempt to remain dry by refactoring the code into a helper method which gets called at the beginning of each test:

While this mostly works, what we’d really like is for the framework to handle this for us so that we can avoid having to put in the extra method calls if possible.

@testSetup – removing repeated code

@testSetup is a new annotation that will allow you to specify methods that the test framework will run just before each test method runs. The test methods must return null and be static (similar to most other testing frameworks) but otherwise can do whatever is needed by your tests. This annotation is totally optional as well, so if you don’t need/don’t like it you don’t have to use it. Continuing our sample from above, we can refactor the code base to:

By being able to gloss over the setup details, the next person who has to maintain these tests can more easily focus on the core concept each method is trying to test hopefully promoting more reliable and robust code.

Wrap Up

We are excited for this new annotation and will be exploring its creative uses when it’s released. As with any new release there are some important caveats to it, so we encourage you to read the documentation on it before attempting to refactor any existing code bases. If you are confused by this or want to know more, feel free to leave us a comment below or contact us!

Topics: Salesforce

Make Your Visualforce Components More Useful, Part 3

Today's post is written by Andrew Monshizadeh, an iOS Developer at Sonoma Partners.

In the first blog post we discussed a situation where it would make sense to split part of a Visualforce page out into a component, and in the second blog post we actually did the work of that split, ending up with an easily reusable component. This time we will discuss a few more advanced uses for a Visualforce Component.

Probably the most useful aspect of a Visualforce Component is that it can contain the same content as a normal Visualforce page; it has access to the standard Visualforce tags, but also HTML, CSS, and Javascript. Therefore, it is possible to build tags that contain only Javascript or styling contents. The benefit of this is the reusability provided by a component. If a component is defined such that it contains all of the necessary references to static resources, say for CSS in a community, then the individual Visualforce pages need only include the one component, which would then provide all of the styling. Even more advanced would be composing the styling of the page with components. This would be accomplished by having components that held the styles for individual aspects of the page, and then placing them either in one container component and including that one component, or adding them in as needed to individual pages.
V3_1

Figure 5 - Bootstrap, JQuery, CSS and Javascript from a component

Another great use for components are buttons that can be used throughout the customized application. Consider a situation where potentially a customer requires a set of Visualforce pages that provide a progression for users. The progression log could be completely stripped from the process pages and moved to a single component. In the example below, this is accomplished by making the component take in the name of the previous and next pages in the progression, then passing those strings into the PageReference(String) constructor. With this pattern, each page only needs to know the name of the previous and next page, but nothing about how to make that transition.
V3_2
V3_3

Lastly, the most complex, but potentially most useful use for Visualforce components: components that can take care of formatting values and then pass those back to the containing Visualforce page. This pattern requires a little more setup than others, but provides so much potential it is easily forgiven. For example, consider that the client wants users to enter names in numerous locations in various Visualforce pages, but each name field will have the same kind of formatting of the input. Look over the screenshots and code below, and then reference the steps that follow for the explanation.
V3_4
Figure 6 - Page after loading


V3_5
Figure 7 - Page as user edits the text field

V3_6
Figure 8 - Page after the component formats the text


V3_7
Figure 9 - Page with message indicating the formatted text is available to the parent page's controller

1. Create a class named DataWrapper. This class will wrap the values you want to pass between the containing Visualforce page's controller and the component. The reason this class is necessary is that by default primitive data types are passed by value and thus copied from the container page's controller to the component, while objects are passed by reference. This matters because a copied value no longer will update the original value. Note that it has only the one internal property, this is all we really want and need, but it must be in an Object so we get the by reference behavior.

2. Create a component named NameInputTextComponent. This is where we will encapsulate all of the formatting logic. The component is not complex for this example, it has one attribute that takes in a DataWrapper type of object, the one <apex:inputText> tag with a <apex:actionSupport> tag. The input is pretty self-explanatory, while the action support tag is used to fire off the formatting function when the input field loses focus.

3. Create a controller for the component (NameInputTextComponentController). This is where all the heavy lifting will be done. It will have a property with the type DataWrapper, a String property to actually be referenced in the component and a method to do the formatting. As discussed before, the formatting method is called by the <apex:actionSupport> tag after the input field loses focus. The input field is bound to the String property, and so gets and sets data to that property. The formatting function is the function that puts the formatted data back into the wrapper.

4. Create a page and controller where this component will be used (NameInputTextPage and NameInputTextPageController, respectively). In the controller is a property of the DataWrapper type, and lazily instantiate it with some wrapped String value. The lazy initialization is not required, but a good habit. Also in the controller is an action function that will be used just to demonstrate that the values that are truly being updated in the component and containing page.

With this simple component, a developer would be able to provide the formatted name fields wherever necessary. For example, the developer could provide a page where users are able to enter some number of names in a table format, click a button, and that number of Contacts are created. With this component, the client could be sure that all of the names would be formatted correctly.

Finally, that simple demonstration should showcase the power of components. They are able to do some pretty heavy lifting, and remove some of the maintenance headache that is part of large Visualforce customization by encapsulating and reusing pieces throughout.

Have questions about Visualforce Components? Let's set up a time to talk.

Topics: Salesforce

Sonoma Partners Community Applications for CRM 2015

Today’s post is co-written by Kevin Yamashita, a Senior Quality Analyst at Sonoma Partners.

With the release of Dynamics 2015, we're excited to announce that our community applications (Editable Grid, Universal Search, Dynamic Forms) have been updated and are now compatible with CRM 2015. As always, these tools are available for both on-prem and online deployments for free!

CRM 2015 introduces Multi-Entity Search functionality for the Web client and also enhanced their Business Rules feature. You may wonder how that impacts Universal Search and Dynamic Forms. Let’s compare each of our community tools to those new features so you can decide which tool will best suit your needs.

Universal Search  (US) vs Multi-Entity Search (MES)

Feature Universal Search Multi-Entity Search Notes
Search Configuration Native Quick Find View Native Quick Find View Both solutions use the Quick Find View to configure the search and return columns
Entity Support Unlimited* 10 max * We still recommend limiting to a reasonable number for performance
Results Display Configurable – unlimited fields from Quick Find* Configurable - first 3 fields of Quick Find * We still recommend limiting to a reasonable number for performance
Tablet Client Access No Yes  
Web Access Application menu CRM masthead MES will always be available for users, while US may not depending on how CRM displays the application menu buttons
Related Record Access Yes No US allows a user to click a link to a related lookup record when returned in the search results
Filter Data Search Yes – using record createdon date No In addition to the native Quick Find configuration, US allows you to filter based on the record createdon date, which can improve performance for large data sets

As you can see from the above comparison, the native multi-entity search now provides much of the same functionality as Universal Search. And with MES’s ‘always available’ placement in the masthead & tablet client support, we recommend starting with MES for your implementations. Since Microsoft made it easy for us to update our 2013 solution for 2015 and a couple of differences still remain, we thought we would keep it available as a free download.

Dynamic Forms (DF) vs. Business Rules (BR)

Feature Dynamic Forms Business Rules Notes
Actions

Error Message Dialog
Field - Require
Field - Hide
Field - Show
Field - Disable
Field - Set
Field - Clear
Form - Disable
Form - Refresh
Form - Save
Section - Show
Section - Hide
Section - Disable
Tab - Show
Tab - Hide
Tab - Disable
JavaScript - Execute Function

Error Message Dialog
Field - Require
Field - Hide
Field - Show
Field - Disable
Field - Set
Field - Clear

 
Conditions

Entity Field
Related Entity Field
Client (Web/ Mobile/Outlook)
Client State (Online/ Offline)
Form
Form Type (Create/ Update/Read Only/Disabled)
Security Role
User Record Field

Entity Field
Value

 
Related Entity Reference Yes No  
Else If Logic No Yes  
“And” or “Or” No Yes BR allows for the use of "and" or "or" logic between conditions, while DF supports only "and" logic
Event Triggers Client-side Both client and server side  
Number of Rules 10* Unlimited * The free community edition allows you a maximum of 10 rules.
Tablet Client Yes Yes  

Unlike Universal Search, Dynamic Forms continues to have advantages, particularly with the number of extra conditions that DF provides. We recommend you consider the functionality you need to provide and decide on the best tool to accomplish it. When you can, keep using the native tools that Microsoft provides and then augment the gaps with DF.

Also, note that our latest solution file downloads for CRM 2015 also should import to CRM 2013 (you should see both versions in the download zip file name).

Topics: Microsoft Dynamics CRM 2015

Duplicate Management and Salesforce Spring ’15

Today's post is written by Richard Failla, a Salesforce Business Analyst at Sonoma Partners.

We told you why we’re excited for Spring ’15 but now we want to dive deeper into one long-awaited feature: native Duplicate Management. While it technically falls under Data.com, it does not require a separate Data.com license to use. So if you’re running Professional Edition or above, follow along as we detail some specifics you can expect when the switch is flipped in your org.

It’s a Plumber, Not a Cleaner

Once enabled, the feature essentially creates a barrier for duplicate records to enter your system. It will not scrub your org for existing duplicates in the first release but we’re hopeful to see this enhancement in the future.

Not All Dupes Are Created Equal

In addition to Accounts, Contacts, and Leads, native Duplicate Management will work with custom objects. It’s good to see support for the core standard objects but adding in custom objects is a huge win for those with more complex orgs.

One Of These Things Is (Not) Like The Other

Any dupe-detection solution requires matching rules and often those rules need to compare data between standard and custom fields. But often we need to go further and cross data between objects. Is your new Lead already a Contact? Crossing standard and custom fields is core to managing duplicate records but to extend the feature and support cross-object detection makes this more robust than anticipated for a first release.

BlogImage1

Warm Fuzzies

Duplicate detection is nothing without the matching algorithm underneath. And rarely will an “exact match” suit our needs. With numerous ways to abbreviate a name, we need to be able to find a match between subtle distinctions like “Incorporated” vs. “Inc.” and 5-digit vs. 9-digit zip codes. The support for “fuzzy match” logic is a great feature to roll out of the gate and Salesforce has even provided preset matching methods to help us get started.

WarmFuzzies

One API To Rule Them All

If you run a data import job via the API and a match is found for a given record, you’ll get an error and that record will not import. However, there is a new Apex Class that theoretically allows developers to force a save for matching records. That should help with those unique cases where you want to avoid turning off a rule just to tend to some admin housekeeping.

OneAPItoRuleThemAll

Search No More

Gone are the painstaking days of training end-users to search for existing records before creating new ones. Now when users try to save a new record, potential duplicate records can pop-up (if found). Users can then peruse these records and even edit the new record’s data on the fly.

Search No More

Agnostic Platforms

Whether your end-users are entering records from their computer, phone, or tablet, native Duplicate Management is supported across all devices running Salesforce or SF1.

The “Silent Reporter”

Any dupe-detection solution brings to the fore the classic dichotomy between administrators and end-users; admins want quality data while end-users want pain-free data entry. Salesforce executed a solution that strives for balance between the two: rather than alerting end-users every time a potential dupe is found (or blocking their entry entirely), admins can now setup reports to track duplicate records on the backend without annoying end-users with popups and alerts on the frontend.

Silent Reporter

Duplicate Management is not a panacea; there are plenty of cases that demand more detailed dupe-detection capabilities. Nevertheless, we’re impressed to see all the nuances Salesforce has packed into the first release of their native Duplicate Management feature. Better yet, releasing it for free for Professional Editions and above goes a long way to help organizations looking to reduce dupes and maximize data quality without breaking the bank on 3rd-party solutions.

Topics: Salesforce

Activity Tracker – Microsoft Dynamics CRM Mobile Samples

Today’s post is co-written by Kyle Gerstner, a Principal Mobility Architect at Sonoma Partners.

With the rush of the holidays, you may not have noticed that the Microsoft Dynamics CRM team released a new set of sample mobile code that demonstrate how to connect and interact with Dynamics CRM from Windows Phone, Android and iOS devices.

Microsoft asked Sonoma Partners to create a sample code solution specifically for iOS and Android developers. In these discussions, we wanted to showcase more than a simple mobile example connecting CRM. We believed we could come up with a quick, easy to understand reference application that leverages the code samples mobile developers would use in common applications, but also be immediately valuable to the user community. Our key solution tenants were:

  • Provide framework for custom mobile applications
  • Phone-based application
  • Simple & common use case
  • Stand-alone reference application
  • No CRM solution changes required

We focused our use case on something every mobile user can appreciate: the ability to quickly find a contact’s details and record an interaction with that person. The results are the Activity Tracker phone sample application!

image

While we focused on the iOS and Android versions, Microsoft developed the Windows Phone in parallel, providing you the code to natively work with whichever device makes sense for your organization.

This starter application code was designed for mobile developers looking to get started with Dynamics CRM for the first time, as well as seasoned Dynamics CRM developers. Activity Tracker demonstrates how to find a contact and submit one type of activity interaction (a check-in task). However, the code is open source, so you have a framework to easily add additional activity types, brand the application to your color scheme, and also add additional entities (such as account and opportunity). You can also look to extend the use case slightly for more advanced scenarios.

To demonstrate, we have extended the application for our internal use to bring back tweets from a contact. We simply added a ‘Twitter Handle’ field to the contact form and use that to make a call to Twitter, retrieving all public tweets associated with that twitter handle. As you can see from the screenshot, we also altered the design of the activity history to use a horizontal scroll, for better usability with more information sources.

 ActivityTracker_TwitterContact

The Microsoft team also has demonstrated extending the application. They have a sample that enhanced the Windows Phone example to use Cortana – bringing the power of voice commands to your CRM data entry!

From a technical perspective, the samples show you how to connect to both the SOAP and OData endpoints that Dynamics CRM uses. As a mobile developer using Dynamics CRM, you will probably use both endpoints in your custom applications.

The OData endpoint is a more common approach for connecting mobile applications, and is the primary approach taken in this sample. For example, we use OData to fetch details of the contact and get the recent records list, which comes back in an easy-to-consume JSON format. However, not all of the Dynamics CRM API methods are currently supported with OData. One example of this, is using the Execute method which was needed to mark an activity as completed. Hence the need to also demonstrate how to interact with the SOAP endpoint.

We also made use of Microsoft’s ADAL library for Objective C and ADAL library for Android, which uses OAuth to authenticate the user to CRM. Like many mobile applications, this means your user authenticates from their appropriate authentication endpoint, with the credentials they already know and commonly use.  More importantly from an application development perspective, the custom application does not need or has access to your username and password. The OAuth model gives the user and system administrators the ability to revoke access if a device is lost or an employee leaves the organization, helping to further reduce the security risks generally associated with mobile applications. 

We believe these mobile samples will allow you to more quickly deploy a customized mobile application for your organization and make your mobile workforce more efficient and engaged.

Ready to mobilize your workforce? We can help. Contact us to learn more about mobile CRM applications for your business.

Topics: Enterprise Mobility Microsoft Dynamics CRM 2015 Microsoft Dynamics CRM Online

CRM 2015 – Scripting Options for Business Process Flows

Since the release of business process flows in CRM 2013, we’ve been clamoring for more extensibility from a scripting standpoint.  With the release of CRM 2015 Microsoft has added several new methods to the javascript API that allow developers to greatly extend the out-of-the-box business process flows capability.

The following is a list of the new API methods from this MSDN article.  We are particularly most excited about the ability to dynamically hide/show the business process flow control.

Change the process when there are more than one process available for the entity.
Use Xrm.Page.data.process.getEnabledProcesses to retrieve information about enabled processes that the user can choose for the entity. Then use Xrm.Page.data.process.setActiveProcess to make one of the enabled processes the active one.

Move to the next stage when all required steps are completed to make it the current active stage.
Use Xrm.Page.data.process.moveNext.

Move to the previous stage and make it the current active stage.
Use Xrm.Page.data.process.movePrevious.

Select a stage to view the status of the steps in the stage.
Use Xrm.Page.data.process.getActivePath to retrieve information about the stages that have been completed, the current active stage, and valid stages available from the current active stage. Examine the steps included in that stage and compare the corresponding form attribute values to determine whether they are completed.

Complete a step
Steps are completed when the corresponding data in the form is entered. You can determine the attribute using the step getAttribute method. This will return the logical name of the attribute. Then use Xrm.Page.getAttribute to retrieve attribute from the Xrm.Page.data.entity.attributes collection and then use the attribute setValue method to set the value.

Detect whether a step is required
Use the step isRequired method to determine if a step is required by the business process flow.

Expand or collapse the business process flow control
Use Xrm.Page.ui.process.setDisplayState.

Hide the process control
Use Xrm.Page.ui.process.setVisible, you can control whether to display the business process flow control.

Skip to a valid completed stage.
Use Xrm.Page.data.process.setActiveStage to set one of the valid completed stages for the current entity.

Query the process definition including stages not currently visible
Use Xrm.Page.data.process.getActiveProcess to query the definition of the business process flow, including stages that might not be visible because of branching logic in the process.

Events for business process flows
You can interact any event provided by the form with business process flows, but two new events allow you to execute code based on events just for the business process flow control. You can execute code when the active stage of a business process flow changes (OnStageChange event) or when a stage is selected (OnStageSelected event).

The SDK team also provided a couple great samples for the new scripting methods.  Check out this sample on how to retrieve information about the enabled processes for an entity and this sample on retrieving information about the stages and steps in the active business process flow path.

Topics: Microsoft Dynamics CRM Microsoft Dynamics CRM 2015 Microsoft Dynamics CRM Online

Make Your Visualforce Components More Useful, Part 2

Today's post is written by Andrew Monshizadeh, an iOS Developer at Sonoma Partners.

In the previous blog post, we discussed a situation where it would be beneficial to break parts of a Visualforce page and Apex backing into a Visualforce component. As a review, the benefit of Visualforce components is that they make it possible to prevent duplication of code. The less code there is overall, the easier it is to test and maintain.

At the end of the last blog post, the naïve approach to the Case and Case Comment list was implemented using a normal <apex:pageBlockTable> tag in the Visualforce page.

1
Figure 3 - Custom page block table

This example is simple. But it isn’t difficult to imagine that a client would want a Visualforce page that included a large number of fields, some for display and some editable, along with validation logic that needs to happen throughout the time the user is on the page, which would need to be done in the Apex controller. Though it would be possible to move the Case Comment based logic to a separate extension controller, this doesn’t solve the problem of truly breaking the code into a reusable chunk. The developer would still need to come back to this page and copy/paste the Visualforce.

Enter Visualforce components.

Visualforce components make it easier to reuse Visualforce and Apex code throughout the entire org. This is because it forces the developer to consider the behavior and content in the component as a stand-alone unit.

The first step to breaking out a component, is determining what exactly should be in the component. It is important at this point to try and determine the smallest set of content and behavior to break out. There is no benefit in carrying around excess baggage. So in this case, the developer would only be interested in the actual table displaying the Case Comments. For this simple example, it is possible to take the original Visualforce and move it into a new component, almost entirely unchanged.

 

Note that the component has its own backing Apex controller. This simplifies the logic within the component’s Visualforce markup because the backing controller can be developed to fit the needs of the component. Therefore, it is possible to contain just the list of Case Comments with no look ups necessary.

 

With this component defined, it is now possible to use it in the original Visualforce page in place of the normal table. This also simplifies the page’s controller, so much so in fact, that it is no longer necessary.

2Figure 4 - Custom page block table but now in a component

Clearly this simplifies the overall Visualforce page development, and does not impact the user experience. Also, it means that this list of Case Comments may be used anywhere Visualforce is used (and an Account object is available) with a minimum amount of code. Finally, by making this a component, any time a change is made to the component that is reflected everywhere the component is used.

In our next and final Visualforce component post, we will discuss a few advanced uses for Visualforce components.

 
Topics: Salesforce

Dynamics CRM 2015 – Advanced Find Returns

Like most users of Dynamics CRM 2013, it’s taking me awhile to get used to the new navigation.  However, with any software deployment, it takes users time to get used to the new functionality and especially the new look and feel. 

It’s hard to remember when CRM 2011 came out (way back almost 4 years ago now) and the introduction of the ribbon.  What a crazy concept the ribbon was and how would we ever get used to it?  However, after using 2011 over time (and honestly any Microsoft product), the ribbon became second nature.  When Microsoft removed the ribbon in 2013, everyone complained it was missing.  How would we now get used to not having a ribbon?  I believe that over time Dynamics CRM 2013 and 2015 will fall into the same camp as 2011 where users will become comfortable using the new navigation and will have forgotten the ribbon ever existed.

We recently just upgraded our internal CRM deployment to 2015 and I’m forced to get used to the navigation even quicker than originally anticipated.  Of course with every new release there are those learning curves and the questions you ask “why did they do it this way?” but the good news is that with Microsoft, they’re listening.

One of the biggest complaints of 2013 is the fact that the Advanced Find was buried and not readily available on the global tool bar like it was in 2011.  In some areas of the application you couldn’t even initiate Advanced Find.  And those areas where you could, you had to click on the ellipsis to bring down additional contextual menu items to find Advanced Find.

SNAGHTML33926d4

However, the good news is in 2015, Microsoft has listened to initial feedback from users of 2013, and have added the Advanced Find menu back in the global tool bar so that you can always initiate Advanced Find no matter where you are in the application. Enjoy!

SNAGHTML3430206

Topics: CRM Upgrade Microsoft Dynamics CRM Microsoft Dynamics CRM 2011 Microsoft Dynamics CRM 2013 Microsoft Dynamics CRM 2015

Data De-Duplication through Fuzzy Matching

Today's guest blogger is Chris LaBadie, a Senior Database Developer at Sonoma Partners

Whenever we work on a data project for a customer the subject of cleaning their client data is always a discussion point.  The project could involve a migration from one CRM platform to another, integrating an ERP system into CRM, or even cleaning their data “in place”- but the message is usually the same, “we know we have duplicates in our data, help us clean it up!”

Anybody that has ever tried to track people or companies knows that it can be a huge challenge to avoid duplicate data.  When you have multiple users maintaining data, it is very common to introduce duplicate data no matter the de-duplication safeguards your system uses. 

Working with people-
•    Names can be difficult to track (misspellings, maiden names, nicknames, etc).
•    People move/change contact information.
•    Even unique fields like address or email address can be shared amongst more than one person. 

Working with companies-
•    Abbreviations or acronyms in names can present a challenge.
•    Companies can have multiple locations.
•    Often use different addresses to track billing, shipping, etc.

In our experience, there isn’t a magic bullet to eliminate de-duplication.  The best solution is usually a layered approach- use form validation to ensure quality data entry, intelligent system design to store records in an organized manner, and system de-duplication rules to search out potential duplicate data and present to a user records that might match the information they are attempting to enter. 

However, a common project for Sonoma Partners is moving a client to a new CRM platform and an important part of migrating data to the new platform is to identify potential duplicate data before it ever reaches the new system.  While this may sound like a large effort, it is actually pretty easy thanks to the Fuzzy Grouping functionality built into SQL Server Integration Services (SSIS). 

Fuzzy Grouping allows SSIS to inspect a set of data and compare one or more fields in the dataset.  Rather than comparing the field data, Fuzzy Grouping will match strings based on their sounds- giving more accurate results based on how a person would hear the string while overcoming misspellings, typos, abbreviations, nicknames, etc.  Note, you will need SQL Server Enterprise or SQL Server Developer edition to use Fuzzy Grouping.  This example is developed using the Business Intelligence Design Studio (BIDS) in SQL Server 2012.

In this demonstration we will process an Excel file of contacts.  This file can be generated from any other system and used in a process like this to identify potential duplicate data before that data is migrated to CRM.  The end result of this process is to produce a file containing potential duplicates so they can be reviewed and cleaned up in the source system before data migration.

Fuzzy Grouping evaluates the file of Contacts and compares them based on selected fields.  Potentially duplicate records are grouped together and assigned a group number.

After Fuzzy Grouping, the process splits so it can sort the results based on their Fuzzy Grouping group number and count the number of records per group. 

Finally, a step to check the group count determines which records are potential dupes- a group count of 1 means the record is unique, anything more than 1 means that group contains 1 or more records that should be reviewed.  The potential duplicates are then exported to an Excel file for review. 

dedupe-new-process 

Configuring Fuzzy Grouping is a pretty straight-forward process, just select the fields you want to compare and set the minimum amount of similarity (roughly a percentage of matching).  This process can involve a little bit of trial and error while you fine-tune the Fuzzy Grouping to identify the records that are potential duplicates without letting through any false positives. 

Typically we will start with lower minimums and go up until we are seeing the desired results.

DeDupeBlog-FuzzyGroup1 

When you run the process, you can see how many records it processes and how many records SSIS ultimately decided to export to Excel for review.

dedupe-new-process-complete 

When the process is complete, you can view the results in your Excel file. Here you can see the unique record number assigned to the record (KeyIn), group number (KeyOut), overall score (percentage of match to the potential duplicate record), similarities for First Name/Last Name/City (percentage of match for each column), and the Group Count (number of potential duplicates per record group).  The highlighted values in the screenshot show some of the values that were compared and demonstrate how Fuzzy Grouping can identify potential duplicates despite common misspellings, nicknames, and partial matches. 

DeDupeBlog-Output-cropped 

In conclusion, Fuzzy Grouping is an easy to use and powerful tool to assist in any data cleanup effort.  It is simple to setup, and quickly evaluates large amounts of data.  SSIS can provide you with all of the tools to make informed decisions regarding your customer data, your most valuable asset.

Topics: Microsoft Dynamics CRM Microsoft Dynamics CRM 2011 Microsoft Dynamics CRM 2013

Spring ’15 – Why we’re excited

Over the holidays, Salesforce posted the Spring ’15 release notes detailing what they’re planning on releasing come mid-February. I’ve poured through them to pull out what I think are the most exciting for both our customers and us.

Duplicate Management now Generally Available

We talked briefly about this in our Winter ’15 preview post, and with this release it has both become Generally Available and includes several improvements. This feature brings improved duplicate detection and blocking to the core Salesforce platform, and contrary to our preview post this feature does not require an extra license (although it does use Data.com technology). Several key enhancements were made from the Beta release in Winter ’15 including:

  • Support for custom objects
  • Ability to define cross object rules for duplicates
  • Support for picklist values
  • APIs and Apex classes added to let developers manage duplicate detection programmatically

There are some limitations to the duplicate detection to be aware of, so as always be sure to read the release notes.

This feature is available in Professional, Enterprise, Performance, Unlimited, and Developer editions.

Analytics Cloud (Wave)

It would be difficult to create this list and justify leaving out Analytics Cloud. Arguably the biggest announcement to come out of Dreamforce this past year, Analytics Cloud is Salesforce’s take on how to do analytics and reporting in a user and mobile friendly way. It’s built on top of the Salesforce platform so there’s no need to host it yourself, but it does cost an additional fee.

This feature is available in Enterprise, Performance, and Unlimited editions.

Exchange Sync (beta)

This feature is actually a combination of 2 new product offerings from Salesforce: an exchange connector which can sync contacts and events to and from an exchange server and Salesforce, and the Salesforce Side Panel. The exchange connector is the beta portion here, giving administrators the ability to set up a connection between Salesforce and Exchange so that users not using Outlook can still have the records sync between the two. Since this is a server side process, no additional software is needed to be installed on the user’s machines.

Create or Edit Records Owned by Inactive Users

This may seem like a silly feature at first, but any business that’s been around for more than a few years will probably have records owned by people who no longer work at the company. Until now, you needed to reassign those records to another user before you could update them. In some cases, especially in integration scenarios, we really just want to update the record no matter who the owner is. With this feature, we can finally do so.

This feature is available in all editions.

Google Maps

With this feature, any record which has a standard address field (Accounts, Contacts, etc) will now display a Google map image of the address if the fields are filled in. Note that Salesforce did send an opt-out notice, and that the feature can always be disabled via the settings menu.

And much more…

Of course, this only scratches the surface of all the improvements made by Salesforce in the upcoming release. If there’s something in particular you are wondering about that we didn’t cover here, feel free to read through the full release notes or contact us and we can help you find what you’re looking for.

Topics: Salesforce