The Drupal 8 version of the Salesforce Suite provides a powerful combination of features that are ready to use and mechanisms for adding custom add-ons you may need. What it does not yet have is lots of good public documentation to explain all those features.
A recent support issue in the Salesforce issue queue asked for example code for writing queries. While I’ll address some of that here, there is ongoing work to replace the query interface to be more like Drupal core’s. Hopefully once that’s complete I’ll get a chance to revise this article, but be warned some of those details may be a little out of date depending on when you read this post.
To run a simple query for all closed Opportunities related to an Account that closed after a specific date you can do something like the following:
$query = new SelectQuery('Opportunity');
$query->fields = [
'Id',
'Name',
'Description',
'CloseDate',
'Amount',
'StageName',
];
$query->addCondition('AccountId', $desiredAccountId, '=');
$query->conditions[] = [
"(StageName", '=', "'Closed Won'",
'OR', 'StageName', '=', "'Closed Lost')",
];
$query->conditions[] = ['CloseDate', '>=', $someSelectedDate];
$sfResponse = \Drupal::service('salesforce.client')->query($query);
The class would need to include a use statement for to get Drupal\salesforce\SelectQuery; And ideally you would embed this in a service that would allow you to inject the Salesforce Client service more correctly, but hopefully you get the idea.
The main oddity in the code above is the handling of query conditions (which is part of what lead to the forthcoming interface changes). You can use the addCondition() method and provide a field name, value, and comparison as lie 10 does. Or you can add an array of terms directly to the conditions array that will be imploded together. Each element of the conditions array will be ANDed together, so OR conditions need to be inserted the way lines 11-14 handle it.
Running a query in the abstract is pretty straight forward, the main question really is what are you going to do with the data that comes from the query. The suite’s main mapping features provide most of what you need for just pulling down data to store in entities, and you should use the entity mapping features until you have a really good reason not to, so the need for direct querying is somewhat limited.
But there are use cases that make sense to run queries directly. Largely these are around pulling down data that needs to be updated in near-real time (so perhaps that list of opportunities would be ones related to my user that were closed in the last week instead of some random account).
I’ve written about using Drupal 8 to proxy remote APIs before. If you look at the sample code you’ll see the comment that says: // Do some useful stuff to build an array of data. Now is your chance to do something useful:
<?php
namespace Drupal\example\Controller;
use Symfony\Component\HttpFoundation\Request;
use Drupal\Core\Controller\ControllerBase;
use Drupal\Core\Cache\CacheableJsonResponse;
use Drupal\Core\Cache\CacheableMetadata;
class ExampleController extends ControllerBase {
public function getJson(Request $request) {
// Securely load the AccountId you want, and set date range.
$data = [];
$query = new SelectQuery('Opportunity');
$query->fields = [
'Id',
'Name',
'Description',
'CloseDate',
'Amount',
'StageName',
];
$query->addCondition('AccountId', $desiredAccountId, '=');
$query->conditions[] = [
"(StageName", '=', "'Closed Won'",
'OR', 'StageName', '=', "'Closed Lost')",
];
$query->conditions[] = ['CloseDate', '>=', $someSelectedDate];
$sfResponse = \Drupal::service('salesforce.client')->query($query);
if (!empty($sfResponse)) {
$data['opp_count'] = $sfResponse->size();
$data['opps'] = [];
if ($data['opp_count']) {
foreach ($sfResponse->records() as $opp) {
$data['opps'][] = $opp->fields();
}
}
}
else {
$data['opp_count'] = 0;
}
// Add Cache settings for Max-age and URL context.
// You can use any of Drupal's contexts, tags, and time.
$data['#cache'] = [
'max-age' => 600,
'contexts' => [
'url',
'user',
],
];
$response = new CacheableJsonResponse($data);
$response->addCacheableDependency(CacheableMetadata::createFromRenderArray($data));
return $response;
}
}
Cautions and Considerations
I left out a couple details above on purpose. Most notable I am not showing ways to get the needed SFID for filtering because you need to apply a little security checking on your route/controller/service. And those checks are probably specific to your project. If you are not careful you could let anonymous users just explore your whole database. It is an easy mistake to make if you do something like use a Salesforce ID as a URL parameter of some kind. You will want to make sure you know who is running queries and that they are allowed to see the data you are about to present. This is on you as the developer, not on Drupal or Salesforce, and I’m not risking giving you a bad example to follow.
Another detail to note is that I used the cache response for a reason. Without caching every request would go through to Salesforce. This is both slower than getting cached results (their REST API is not super fast and you are proxying through Drupal along the way), and leaves you open to a simple DOS where someone makes a bunch of calls and sucks up all your API requests for the day. Think carefully before limiting or removing those cache options (and make sure your cache actually works in production). Setting a context of both URL and User can help ensure the right people see the right data at the right time.
