Add constrain to check if plugin can be published.

app/bundles/PluginBundle/Config/config.php

@@ -78,6 +78,13 @@
                     'mautic.factory',
                 ],
             ],
+            'mautic.plugin.validator.can_publish_validator' => [
+                'class'     => Mautic\PluginBundle\Form\Constraint\CanPublishValidator::class,
+                'arguments' => [
+                    'event_dispatcher',
+                ],
+                'tag'   => 'validator.constraint_validator',
+            ],
         ],
         'facades' => [
             'mautic.plugin.facade.reload' => [

app/bundles/PluginBundle/Controller/PluginController.php

@@ -169,9 +169,9 @@
         $leadFields    = $pluginModel->getLeadFields();
         $companyFields = $pluginModel->getCompanyFields();
         /** @var AbstractIntegration $integrationObject */
-        $entity = $integrationObject->getIntegrationSettings();
-
-        $form = $this->createForm(
+        $entity                 = $integrationObject->getIntegrationSettings();
+        $existingPublishedState = $entity->getIsPublished();
+        $form                   = $this->createForm(
             DetailsType::class,
             $entity,
             [
@@ -203,6 +203,9 @@
                                 $keys[$secretKey] = $currentKeys[$secretKey];
                             }
                         }
+                        $keys = $this->removeAuthData($keys, $currentKeys, $integrationObject);
+                        $integrationObject->encryptAndSetApiKeys($keys, $entity);
+
                         $integrationObject->encryptAndSetApiKeys($keys, $entity);
                     }
 
@@ -254,6 +257,9 @@
                         $mauticLogger->info('Dispatching integration config save event.');
                         if ($dispatcher->hasListeners(PluginEvents::PLUGIN_ON_INTEGRATION_CONFIG_SAVE)) {
                             $mauticLogger->info('Event dispatcher has integration config save listeners.');
+                            if (!$valid && !$existingPublishedState) {
+                                $integrationObject->getIntegrationSettings()->setIsPublished(false);
+                            }
                             $event = new PluginIntegrationEvent($integrationObject);
 
                             $dispatcher->dispatch($event, PluginEvents::PLUGIN_ON_INTEGRATION_CONFIG_SAVE);
@@ -432,4 +438,33 @@
             ]
         );
     }
+
+    /**
+     * @param array <string,mixed> $keys
+     * @param array <string,mixed> $currentKeys
+     *
+     * @return array <string,mixed>
+     *
+     * @phpstan-ignore-next-line
+     */
+    private function removeAuthData(array $keys, array $currentKeys, AbstractIntegration $integrationObject): array
+    {
+        $resetTokens = false;
+        $secretKeys  = array_unique(array_merge($integrationObject->getSecretKeys(), [$integrationObject->getClientIdKey()]));
+
+        foreach ($secretKeys as $secretKey) {
+            if (($keys[$secretKey] ?? null) !== ($currentKeys[$secretKey] ?? null)) {
+                $resetTokens = true;
+                break;
+            }
+        }
+
+        if (!$resetTokens) {
+            return $keys;
+        }
+
+        $keysToRemove = array_unique(array_merge($integrationObject->getRefreshTokenKeys(), [$integrationObject->getAuthTokenKey()]));
+
+        return array_diff_key($keys, array_flip($keysToRemove));
+    }
 }

app/bundles/PluginBundle/Event/PluginIsPublishedEvent.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mautic\PluginBundle\Event;
+
+class PluginIsPublishedEvent extends \Symfony\Contracts\EventDispatcher\Event
+{
+    private string $message;
+    private bool $canPublish;
+
+    public function __construct(private int $value, private string $integrationName)
+    {
+        $this->canPublish      = true;
+        $this->message         = '';
+    }
+
+    public function getValue(): int
+    {
+        return $this->value;
+    }
+
+    public function getMessage(): string
+    {
+        return $this->message;
+    }
+
+    public function setMessage(string $message): void
+    {
+        $this->message = $message;
+    }
+
+    public function isCanPublish(): bool
+    {
+        return $this->canPublish;
+    }
+
+    public function setCanPublish(bool $canPublish): void
+    {
+        $this->canPublish = $canPublish;
+    }
+
+    public function getIntegrationName(): string
+    {
+        return $this->integrationName;
+    }
+}

app/bundles/PluginBundle/Exception/ApiErrorException.php

@@ -10,6 +10,8 @@ class ApiErrorException extends \Exception
 
     private ?Lead $contact = null;
 
+    private string $shortMessage = '';
+
     /**
      * @param string $message
      * @param int    $code
@@ -56,4 +58,16 @@ public function setContact(Lead $contact)
 
         return $this;
     }
+
+    public function getShortMessage(): string
+    {
+        return $this->shortMessage;
+    }
+
+    public function setShortMessage(string $shortMessage): ApiErrorException
+    {
+        $this->shortMessage = $shortMessage;
+
+        return $this;
+    }
 }

app/bundles/PluginBundle/Form/Constraint/CanPublish.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mautic\PluginBundle\Form\Constraint;
+
+use Symfony\Component\Validator\Constraint;
+
+class CanPublish extends Constraint
+{
+    public string $message =  'mautic.lead_list.not_allowed_plugin_publish';
+
+    public string $integrationName;
+
+    public function getDefaultOption(): string
+    {
+        return 'integrationName';
+    }
+}

app/bundles/PluginBundle/Form/Constraint/CanPublishValidator.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mautic\PluginBundle\Form\Constraint;
+
+use Mautic\PluginBundle\Event\PluginIsPublishedEvent;
+use Mautic\PluginBundle\PluginEvents;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+
+class CanPublishValidator extends ConstraintValidator
+{
+    public function __construct(private EventDispatcherInterface $eventDispatcher)
+    {
+    }
+
+    public function validate($value, Constraint $constraint): void
+    {
+        if (1 !== $value) {
+            return;
+        }
+        if (!$constraint instanceof CanPublish) {
+            throw new \Symfony\Component\Validator\Exception\UnexpectedTypeException($constraint, CanPublish::class);
+        }
+        $event = new PluginIsPublishedEvent($value, $constraint->integrationName);
+        $event = $this->eventDispatcher->dispatch($event, PluginEvents::PLUGIN_IS_PUBLISHED_STATE_CHANGING);
+
+        if (!$event->isCanPublish()) {
+            $this->context->buildViolation($event->getMessage())
+                ->addViolation();
+        }
+    }
+}

app/bundles/PluginBundle/Form/Type/DetailsType.php

@@ -6,6 +6,7 @@
 use Mautic\CoreBundle\Form\Type\StandAloneButtonType;
 use Mautic\CoreBundle\Form\Type\YesNoButtonGroupType;
 use Mautic\PluginBundle\Entity\Integration;
+use Mautic\PluginBundle\Form\Constraint\CanPublish;
 use Mautic\PluginBundle\Integration\AbstractIntegration;
 use Symfony\Component\Form\AbstractType;
 use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
@@ -22,7 +23,11 @@ class DetailsType extends AbstractType
 {
     public function buildForm(FormBuilderInterface $builder, array $options): void
     {
-        $builder->add('isPublished', YesNoButtonGroupType::class);
+        $builder->add('isPublished', YesNoButtonGroupType::class, [
+            'constraints' => [
+                new CanPublish($options['integration'] ?? ''),
+            ],
+        ]);
 
         /** @var AbstractIntegration $integrationObject */
         $integrationObject = $options['integration_object'];

app/bundles/PluginBundle/Form/Type/FeatureSettingsType.php

@@ -47,7 +47,7 @@ public function buildForm(FormBuilderInterface $builder, array $options): void
             $settings = [
                 'silence_exceptions' => false,
                 'feature_settings'   => $data,
-                'ignore_field_cache' => (1 == $page && 'POST' !== $_SERVER['REQUEST_METHOD']) ? true : false,
+                'ignore_field_cache' => 1 == $page && 'POST' !== ($_SERVER['REQUEST_METHOD'] ?? null),
             ];
 
             try {

app/bundles/PluginBundle/Integration/AbstractIntegration.php

@@ -96,7 +96,8 @@
 
     protected array $persistIntegrationEntities = [];
 
-    protected array $commandParameters         = [];
+    protected array $commandParameters = [];
+    private \Closure $clientFactory;
 
     public function __construct(
         protected EventDispatcherInterface $dispatcher,
@@ -119,6 +120,12 @@
         $this->cache                  = $cacheStorageHelper->getCache($this->getName());
         $this->session                = (!defined('IN_MAUTIC_CONSOLE')) ? $session : null;
         $this->request                = (!defined('IN_MAUTIC_CONSOLE')) ? $requestStack->getCurrentRequest() : null;
+
+        $this->setClientFactory(fn (array $options): \GuzzleHttp\Client => new Client([
+            'handler' => HandlerStack::create(new CurlHandler([
+                'options' => $options,
+            ])),
+        ]));
     }
 
     public function setCommandParameters(array $params): void
@@ -795,12 +802,16 @@
                     break;
             }
         } catch (\GuzzleHttp\Exception\RequestException $exception) {
-            return [
-                'error' => [
-                    'message' => $exception->getResponse()->getBody()->getContents(),
-                    'code'    => $exception->getCode(),
-                ],
-            ];
+            if (!empty($settings['return_raw'])) {
+                return $exception->getResponse();
+            } else {
+                return [
+                    'error' => [
+                        'message' => $exception->getResponse()->getBody()->getContents(),
+                        'code'    => $exception->getCode(),
+                    ],
+                ];
+            }
         }
         if (empty($settings['ignore_event_dispatch'])) {
             $event->setResponse($result);
@@ -2435,6 +2446,14 @@
         return $records;
     }
 
+    /**
+     * @param callable(mixed[]): Client $clientFactory
+     */
+    public function setClientFactory(callable $clientFactory): void
+    {
+        $this->clientFactory = \Closure::fromCallable($clientFactory);
+    }
+
     /**
      * Because so many integrations extend this class and mautic.http.client is not in the
      * constructor at the time of writing, let's just create a new client here. In addition,
@@ -2444,8 +2463,6 @@
      */
     protected function makeHttpClient(array $options): Client
     {
-        return new Client(['handler' => HandlerStack::create(new CurlHandler([
-            'options' => $options,
-        ]))]);
+        return ($this->clientFactory)($options);
     }
 }

app/bundles/PluginBundle/MauticPluginBundle.php

@@ -1,9 +1,19 @@
 <?php
 
+declare(strict_types=1);
+
 namespace Mautic\PluginBundle;
 
+use Mautic\PluginBundle\Tests\DependencyInjection\Compiler\TestPass;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\HttpKernel\Bundle\Bundle;
 
 class MauticPluginBundle extends Bundle
 {
+    public function build(ContainerBuilder $container): void
+    {
+        if ('test' === $container->getParameter('kernel.environment')) {
+            $container->addCompilerPass(new TestPass());
+        }
+    }
 }

app/bundles/PluginBundle/PluginEvents.php

@@ -133,4 +133,13 @@ final class PluginEvents
      * @var string
      */
     public const ON_PLUGIN_INSTALL = 'mautic.plugin.on_plugin_install';
+
+    /**
+     * The mautic.plugin.is_published_state_changing event is dispatched when a user tries to changes plugin is published state.
+     *
+     * The event listener receives a Mautic\PluginBundle\Event\PluginPublishedEvent instance.
+     *
+     * @var string
+     */
+    public const PLUGIN_IS_PUBLISHED_STATE_CHANGING= 'mautic.plugin.is_published_state_changing';
 }

app/bundles/PluginBundle/Tests/Controller/PluginControllerTest.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mautic\PluginBundle\Tests\Controller;
+
+use Mautic\CoreBundle\Test\MauticMysqlTestCase;
+use PHPUnit\Framework\Assert;
+use Symfony\Component\HttpFoundation\Request;
+
+class PluginControllerTest extends MauticMysqlTestCase
+{
+    public function testConfigurePluginSuccessValidation(): void
+    {
+        $crawler    = $this->client->request(Request::METHOD_GET, '/s/plugins/config/Twilio');
+        $form       = $crawler->filter('form')->form();
+
+        $form->setValues([
+            'integration_details' => [
+                'isPublished' => 0,
+                'apiKeys'     => [
+                    'username' => 'valid_username',
+                    'password' => 'valid_password',
+                ],
+            ],
+        ]);
+
+        $this->client->submit($form);
+        Assert::assertTrue($this->client->getResponse()->isOk());
+    }
+
+    public function testConfigurePluginValidationError(): void
+    {
+        $crawler    = $this->client->request(Request::METHOD_GET, '/s/plugins/config/Twilio');
+        $form       = $crawler->filter('form')->form();
+
+        $form->setValues([
+            'integration_details' => [
+                'isPublished' => 1,
+                'apiKeys'     => [
+                    'username' => '',
+                    'password' => 'bbb',
+                ],
+            ],
+        ]);
+
+        $crawler     = $this->client->submit($form);
+        Assert::assertStringContainsString('A value is required.', $crawler->filter('#integration_details_apiKeys div')->html());
+    }
+}