php-arsenal/salesforce-outbound-message-bundle

This package is abandoned and no longer maintained. No replacement package was suggested.

This bundle allows you to easily process outbound messages sent by Salesforce.

1.1.0 2021-05-05 09:03 UTC

Requires

• php: >=7.4
• ext-json: *
• ext-soap: *
• doctrine/mongodb-odm: ^2.2
• php-arsenal/document-value-updater: ^0.1.1
• php-arsenal/salesforce-mapper-bundle: ^4.0
• symfony/config: ^5.2
• symfony/dependency-injection: ^5.2
• symfony/event-dispatcher: ^5.2
• symfony/http-kernel: ^5.2
• symfony/polyfill-apcu: ^1.22
• symfony/property-access: ^5.2

Requires (Dev)

• dg/bypass-finals: ^1.3
• phpunit/php-code-coverage: ^9.2
• phpunit/phpunit: ^9.5

Provides

• ext-mongo: *

MIT

README

Create, update, remove objects in Symfony sent through Salesforce outbound messages.

Requirements

This bundle assumes you're using:

1. MongoDB database (and specifically doctrine/mongodb-odm).
2. php-arsenal/salesforce-mapper-bundle for Salesforce object mapping to your MongoDB Document classes.

Bundle features

• Object create
• Object update
• Object delete. To enable this complete additional setup steps.
• Object custom handling beforeFlush
• Object custom handling afterFlush

Installation

• composer require php-arsenal/salesforce-outbound-message-bundle
• Register the bundle in your AppKernel.php by adding new PhpArsenal\SalesforceOutboundMessageBundle\SalesforceOutboundMessageBundle()
• To handle the Salesforce's incoming outbound messages create a route (for example /sync) and a method to a controller:

<?php

use Symfony\Component\HttpFoundation\Request;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use PhpArsenal\SalesforceOutboundMessageBundle\Services\RequestHandler\OutboundMessageRequestHandler;

class OutboundMessageController extends Controller
{
    public function syncAction(Request $request, OutboundMessageRequestHandler $requestHandler)
    {
        try {
            $outboundMessageXml = $request->getContent();
            return $requestHandler->handle($outboundMessageXml);
        }
        catch (\Throwable $e) {
            throw new \SoapFault("Server", $e->getMessage());
        }
    }
}

• add the bundle configuration in your app/config/config.yml

salesforce_outbound_message:
    # WSDL_CACHE_NONE, WSDL_CACHE_DISK, WSDL_CACHE_MEMORY or WSDL_CACHE_BOTH
    wsdl_cache: 'WSDL_CACHE_DISK'                     
    # An absolute path to Salesforce object WSDL files
    wsdl_directory: '/absolute/path/' 
    document_paths:
        # Map a document using its Salesforce name and your local class 
        CustomObject__c:              
            path: 'YourNamespace\Documents\CustomObject'
            force_compare: false # if true, incoming object will be compared to existing ones in the database; will continue sync only if not equal

• Add DocumentInterface to the document class you'd like to be tracked by the OutboundMessageBundle.

<?php

use PhpArsenal\SalesforceOutboundMessageBundle\Interfaces\DocumentInterface;
use PhpArsenal\Salesforce\MapperBundle\Model\Account as BaseAccount;

class Account extends BaseAccount implements DocumentInterface
{
}

• Create an EventSubscriber for an object you'd like to sync. It would look something like this for the Account object:

<?php

namespace YourNamespace\EventSubscriber;

use PhpArsenal\SalesforceOutboundMessageBundle\Event\OutboundMessageBeforeFlushEvent;
use PhpArsenal\SalesforceOutboundMessageBundle\Event\OutboundMessageAfterFlushEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use PhpArsenal\SalesforceOutboundMessageBundle\Interfaces\DocumentInterface; 
use PhpArsenal\Webservice\Core\UserBundle\Document\Account;

class AccountSoapRequestSubscriber implements EventSubscriberInterface
{
    public static function getSubscribedEvents()
    {
        return [
            OutboundMessageBeforeFlushEvent::NAME => [
                ['onBeforeFlush'],
            ],
            OutboundMessageAfterFlushEvent::NAME => [
                ['onAfterFlush'],
            ],
        ];
    }

    public function supports(DocumentInterface $document): bool
    {
        $documentClass = get_class($document);

        return Account::class == $documentClass || $document instanceof Account;
    }

    public function onBeforeFlush(OutboundMessageBeforeFlushEvent $event)
    {
        /**
         * Make sure to do call $this->supports() before you start processing the object
         * You only want to process the correct object in this EventSubscriber (which is Account in this case)
         */
        /** @var Account $newAccount */
        $newAccount = $event->getNewDocument();
        
        if (!$this->supports($newAccount)) return; 
    
        /** @var Account $existingAccount */
        $existingAccount = $event->getExistingDocument();
        
        /**
         * You can do any modifications you want to the object before it get's saved (flushed) to the database.
         * - - -
         * $event->getExistingDocument() provides you access to the existing object (if it exists) 
         * $event->getNewDocument() provides you access to the new object delivered by the outbound message. This is the object that will be merged over the existing one (if any) and saved to the database. In most of the cases you only need to use this one.
         */
    }

    public function onAfterFlush(OutboundMessageAfterFlushEvent $event)
    {
        /** @var Account $account */
        $account = $event->getDocument();

        if (!$this->supports($account)) return; 

        /**
         * You can process the object further if necessary after it has been saved (flushed) to the database.
         */
    }
}

• Add your newly created route to the Salesforce outbound message for the object you want to sync (Account in our example).
• That's it! Trigger an outbound message to be sent out and see everything happen automagically. 😎 👍

License

This project is licensed under the MIT License.