├── Assets
    ├── img
    │   └── icon.png
    └── js
    │   └── sqlconditions.js
├── Config
    └── config.php
├── Controller
    └── SqlConditionsController.php
├── Entity
    ├── SqlConditions.php
    └── SqlConditionsRepository.php
├── Event
    └── SqlConditionsEvent.php
├── EventListener
    └── CampaignConditionSubscriber.php
├── Executioner
    ├── Params
    │   └── Params.php
    ├── QueryBuilder.php
    ├── SqlConditionDetails.php
    └── SqlExecutioner.php
├── Form
    └── Type
    │   ├── SqlConditionsCampaignType.php
    │   ├── SqlConditionsType.php
    │   └── SqlListType.php
├── Integration
    └── SqlConditionsIntegration.php
├── MauticSqlConditionsBundle.php
├── Model
    └── SqlConditionsModel.php
├── README.md
├── Security
    └── Permissions
    │   └── SqlConditionsPermissions.php
├── SqlConditionsEvents.php
├── Translations
    └── en_US
    │   └── messages.ini
├── Views
    ├── FormTheme
    │   └── SqlConditionsList
    │   │   └── sqlConditions_list_row.html.php
    ├── Integration
    │   └── form.html.php
    └── SqlConditions
    │   ├── details.html.php
    │   ├── form.html.php
    │   ├── index.html.php
    │   └── list.html.php
└── composer.json


/Assets/img/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mtcextendee/mautic-sql-conditions-bundle/2d5ba75c0a08da72653d74f056e5e2906b611dce/Assets/img/icon.png


--------------------------------------------------------------------------------
/Assets/js/sqlconditions.js:
--------------------------------------------------------------------------------
 1 | Mautic.disabledSqlConditionsActions = function(opener) {
 2 |     if (typeof opener == 'undefined') {
 3 |         opener = window;
 4 |     }
 5 |     var email = opener.mQuery('#campaignevent_properties_sql').val();
 6 | 
 7 |     var disabled = email === '' || email === null;
 8 | 
 9 |     opener.mQuery('#campaignevent_properties_editButton').prop('disabled', disabled);
10 | };
11 | 
12 | Mautic.standardSqlConditionsUrl = function(options) {
13 | 
14 |     if (!options) {
15 |         return;
16 |     }
17 | 
18 |     var url = options.windowUrl;
19 |     if (url) {
20 |         var editKey = '/sqlConditions/edit/objectId';
21 |         if (url.indexOf(editKey) > -1) {
22 |             options.windowUrl = url.replace('objectId', mQuery('#campaignevent_properties_sql').val());
23 |         }
24 |     }
25 | 
26 |     return options;
27 | };
28 | 


--------------------------------------------------------------------------------
/Config/config.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * @copyright   2019 Mautic Contributors. All rights reserved
  5 |  * @author      Mautic
  6 |  *
  7 |  * @link        http://mautic.org
  8 |  *
  9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 10 |  */
 11 | 
 12 | return [
 13 |     'name'        => 'SqlConditions',
 14 |     'description' => 'SQL conditions for Mautic',
 15 |     'author'      => 'mtcextendee.com',
 16 |     'version'     => '1.0.0',
 17 |     'services'    => [
 18 |         'events'  => [
 19 |             'mautic.sqlConditions.campaign.condition.subscriber' => [
 20 |                 'class'     => \MauticPlugin\MauticSqlConditionsBundle\EventListener\CampaignConditionSubscriber::class,
 21 |                 'arguments' => [
 22 |                     'mautic.sqlConditions.executioner',
 23 |                 ],
 24 |             ],
 25 |         ],
 26 |         'forms'   => [
 27 |             'mautic.sqlConditions.form.campaign.type' => [
 28 |                 'class'     => \MauticPlugin\MauticSqlConditionsBundle\Form\Type\SqlListType::class,
 29 |                 'arguments' => [
 30 |                 ],
 31 |             ],
 32 |             'mautic.sqlConditions.form.list.type' => [
 33 |                 'class'     => \MauticPlugin\MauticSqlConditionsBundle\Form\Type\SqlConditionsCampaignType::class,
 34 |                 'arguments' => 'router',
 35 |                 'alias'     => 'sqlconditions_list',
 36 |             ],
 37 |         ],
 38 |         'command' => [
 39 | 
 40 |         ],
 41 |         'other'   => [
 42 |             'mautic.sqlConditions.executioner' => [
 43 |                 'class' => \MauticPlugin\MauticSqlConditionsBundle\Executioner\SqlExecutioner::class,
 44 |                 'arguments' => [
 45 |                     'mautic.sqlConditions.executioner.condition.details',
 46 |                     'mautic.sqlConditions.executioner.query.builder',
 47 |                 ],
 48 |             ],
 49 |             'mautic.sqlConditions.executioner.condition.details' => [
 50 |                 'class' => \MauticPlugin\MauticSqlConditionsBundle\Executioner\SqlConditionDetails::class,
 51 |                 'arguments'=>[
 52 |                     'mautic.sqlConditions.model.sqlConditions'
 53 |                 ]
 54 |             ],
 55 |             'mautic.sqlConditions.executioner.params' => [
 56 |                 'class' => \MauticPlugin\MauticSqlConditionsBundle\Executioner\Params\Params::class,
 57 |             ],
 58 |             'mautic.sqlConditions.executioner.query.builder' => [
 59 |                 'class' => \MauticPlugin\MauticSqlConditionsBundle\Executioner\QueryBuilder::class,
 60 |                 'arguments'=>[
 61 |                     'doctrine.orm.entity_manager',
 62 |                     'mautic.sqlConditions.executioner.params'
 63 |                 ]
 64 |             ],
 65 |         ],
 66 | 
 67 |         'helpers'      => [],
 68 |         'models'       => [
 69 |             'mautic.sqlConditions.model.sqlConditions' => [
 70 |                 'class' => \MauticPlugin\MauticSqlConditionsBundle\Model\SqlConditionsModel::class,
 71 |             ],
 72 |         ],
 73 |         'integrations' => [
 74 |             'mautic.integration.sqlconditions' => [
 75 |                 'class' => \MauticPlugin\MauticSqlConditionsBundle\Integration\SqlConditionsIntegration::class,
 76 |                 'arguments' => [
 77 |                     'event_dispatcher',
 78 |                     'mautic.helper.cache_storage',
 79 |                     'doctrine.orm.entity_manager',
 80 |                     'session',
 81 |                     'request_stack',
 82 |                     'router',
 83 |                     'translator',
 84 |                     'logger',
 85 |                     'mautic.helper.encryption',
 86 |                     'mautic.lead.model.lead',
 87 |                     'mautic.lead.model.company',
 88 |                     'mautic.helper.paths',
 89 |                     'mautic.core.model.notification',
 90 |                     'mautic.lead.model.field',
 91 |                     'mautic.plugin.model.integration_entity',
 92 |                     'mautic.lead.model.dnc',
 93 |                 ],
 94 |             ],
 95 |         ],
 96 |     ],
 97 |     'routes'      => [
 98 |         'main' => [
 99 |             'mautic_sqlConditions_index'  => [
100 |                 'path'       => '/sqlConditions/{page}',
101 |                 'controller' => 'MauticSqlConditionsBundle:SqlConditions:index',
102 |             ],
103 |             'mautic_sqlConditions_action' => [
104 |                 'path'       => '/sqlConditions/{objectAction}/{objectId}',
105 |                 'controller' => 'MauticSqlConditionsBundle:SqlConditions:execute',
106 |             ],
107 |         ],
108 |     ],
109 |     'menu'        => [
110 |         'main' => [
111 |             'items' => [
112 |                 'mautic.sqlConditions' => [
113 |                     'route'    => 'mautic_sqlConditions_index',
114 |                     'priority' => 49,
115 |                     'iconClass' => 'fa fa-database',
116 |                     'checks'   => [
117 |                         'integration' => [
118 |                             'SqlConditions' => [
119 |                                 'enabled' => true,
120 |                             ],
121 |                         ],
122 |                     ],
123 |                 ],
124 |             ],
125 |         ],
126 |     ],
127 |     'categories' => [
128 |         'plugin:sqlConditions' => 'mautic.sqlConditions',
129 |     ],
130 | ];
131 | 


--------------------------------------------------------------------------------
/Controller/SqlConditionsController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * @copyright   2019 Mautic Contributors. All rights reserved
  5 |  * @author      Mautic
  6 |  *
  7 |  * @link        http://mautic.org
  8 |  *
  9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 10 |  */
 11 | 
 12 | namespace MauticPlugin\MauticSqlConditionsBundle\Controller;
 13 | 
 14 | use Mautic\CoreBundle\Controller\AbstractStandardFormController;
 15 | use Mautic\PluginBundle\Helper\IntegrationHelper;
 16 | use Symfony\Component\HttpFoundation\JsonResponse;
 17 | 
 18 | class SqlConditionsController extends AbstractStandardFormController
 19 | {
 20 | 
 21 |     /**
 22 |      * {@inheritdoc}
 23 |      */
 24 |     protected function getJsLoadMethodPrefix()
 25 |     {
 26 |         return 'sqlConditions';
 27 |     }
 28 | 
 29 |     /**
 30 |      * {@inheritdoc}
 31 |      */
 32 |     protected function getModelName()
 33 |     {
 34 |         return 'sqlConditions.sqlConditions';
 35 |     }
 36 | 
 37 |     /**
 38 |      * {@inheritdoc}
 39 |      */
 40 |     protected function getRouteBase()
 41 |     {
 42 |         return 'sqlConditions';
 43 |     }
 44 | 
 45 |     /***
 46 |      * @param null $objectId
 47 |      *
 48 |      * @return string
 49 |      */
 50 |     protected function getSessionBase($objectId = null)
 51 |     {
 52 |         return 'sqlConditions'.(($objectId) ? '.'.$objectId : '');
 53 |     }
 54 | 
 55 |     /**
 56 |      * @return string
 57 |      */
 58 |     protected function getControllerBase()
 59 |     {
 60 |         return 'MauticSqlConditionsBundle:SqlConditions';
 61 |     }
 62 | 
 63 |     /**
 64 |      * @return \Symfony\Component\HttpFoundation\JsonResponse|\Symfony\Component\HttpFoundation\RedirectResponse
 65 |      */
 66 |     public function batchDeleteAction()
 67 |     {
 68 |         return $this->batchDeleteStandard();
 69 |     }
 70 | 
 71 |     /**
 72 |      * @param $objectId
 73 |      *
 74 |      * @return \Mautic\CoreBundle\Controller\Response|\Symfony\Component\HttpFoundation\JsonResponse|\Symfony\Component\HttpFoundation\RedirectResponse
 75 |      */
 76 |     public function cloneAction($objectId)
 77 |     {
 78 |         return $this->cloneStandard($objectId);
 79 |     }
 80 | 
 81 |     /**
 82 |      * @param      $objectId
 83 |      * @param bool $ignorePost
 84 |      *
 85 |      * @return \Mautic\CoreBundle\Controller\Response|\Symfony\Component\HttpFoundation\JsonResponse
 86 |      */
 87 |     public function editAction($objectId, $ignorePost = false)
 88 |     {
 89 |         return $this->editStandard($objectId, $ignorePost);
 90 |     }
 91 | 
 92 |     /**
 93 |      * @param int $page
 94 |      *
 95 |      * @return \Mautic\CoreBundle\Controller\Response|\Symfony\Component\HttpFoundation\JsonResponse|\Symfony\Component\HttpFoundation\RedirectResponse
 96 |      */
 97 |     public function indexAction($page = 1)
 98 |     {
 99 |         return $this->indexStandard($page);
100 |     }
101 | 
102 |     /**
103 |      * @return \Mautic\CoreBundle\Controller\Response|\Symfony\Component\HttpFoundation\JsonResponse
104 |      */
105 |     public function newAction()
106 |     {
107 |         return $this->newStandard();
108 |     }
109 | 
110 | 
111 |     /**
112 |      * @param $objectId
113 |      *
114 |      * @return array|\Symfony\Component\HttpFoundation\JsonResponse|\Symfony\Component\HttpFoundation\RedirectResponse|\Symfony\Component\HttpFoundation\Response
115 |      */
116 |     public function viewAction($objectId)
117 |     {
118 |         return $this->viewStandard($objectId, $this->getModelName(), null, null, 'entity');
119 |     }
120 | 
121 |     /**
122 |      * @param $args
123 |      * @param $action
124 |      *
125 |      * @return mixed
126 |      */
127 |     protected function getViewArguments(array $args, $action)
128 |     {
129 |         $viewParameters = [];
130 |         switch ($action) {
131 |             case 'new':
132 |             case 'edit':
133 |                 break;
134 |             case 'view':
135 |                 break;
136 |         }
137 |         $args['viewParameters'] = array_merge($args['viewParameters'], $viewParameters);
138 | 
139 |         return $args;
140 |     }
141 | 
142 | 
143 |     /**
144 |      * @param $objectId
145 |      *
146 |      * @return \Symfony\Component\HttpFoundation\JsonResponse|\Symfony\Component\HttpFoundation\RedirectResponse
147 |      */
148 |     protected function deleteAction($objectId)
149 |     {
150 |         return $this->deleteStandard($objectId);
151 |     }
152 | 
153 |     protected function getDefaultOrderColumn()
154 |     {
155 |         return 'id';
156 |     }
157 | 
158 | 
159 |     /**
160 |      * @param int $objectId
161 |      *
162 |      * @return JsonResponse|\Symfony\Component\HttpFoundation\Response
163 |      */
164 |     public function batchCronsAction($objectId = 0)
165 |     {
166 |         /** @var \Mautic\LeadBundle\Model\LeadModel $model */
167 |         $model = $this->getModel('sqlConditions');
168 |         /** @var IntegrationHelper $integrationHelper */
169 |         $integrationHelper = $this->get('mautic.helper.integration');
170 |         $integration = $integrationHelper->getIntegrationObject('SqlConditions');
171 | 
172 |         if (false === $integration || !$integration->getIntegrationSettings()->getIsPublished()) {
173 |             return;
174 |         }
175 |         $settings = $integration->mergeConfigToFeatureSettings();
176 |         $ids  = $this->request->get('ids');
177 |         $entities = $model->getEntities(
178 |             [
179 |                 'filter'           => [
180 |                     'force' => [
181 |                         [
182 |                             'column' => 'e.id',
183 |                             'expr'   => 'in',
184 |                             'value'  => $ids,
185 |                         ],
186 |                     ],
187 |                 ],
188 |                 'ignore_paginator' => true,
189 |             ]
190 |         );
191 |         return $this->delegateView(
192 |             [
193 |                 'viewParameters'  => [
194 |                     'entities' => $entities,
195 |                     'crons' => $settings['crons'],
196 |                     'pathsHelper' => $this->get('mautic.helper.paths'),
197 |                 ],
198 |                 'contentTemplate' => 'MauticSqlConditionsBundle:Batch:crons.html.php',
199 |             ]
200 |         );
201 |     }
202 | 
203 | 
204 |     /**
205 |      * @param array $args
206 |      * @param       $action
207 |      *
208 |      * @return array
209 |      */
210 |     protected function getPostActionRedirectArguments(array $args, $action)
211 |     {
212 |         $updateSelect = ($this->request->getMethod() == 'POST')
213 |             ? $this->request->request->get('sqlConditions[updateSelect]', false, true)
214 |             : $this->request->get(
215 |                 'updateSelect',
216 |                 false
217 |             );
218 |         if ($updateSelect) {
219 |             switch ($action) {
220 |                 case 'new':
221 |                 case 'edit':
222 |                     $passthrough = $args['passthroughVars'];
223 |                     $passthrough = array_merge(
224 |                         $passthrough,
225 |                         [
226 |                             'updateSelect' => $updateSelect,
227 |                             'id'           => $args['entity']->getId(),
228 |                             'name'         => $args['entity']->getName(),
229 |                         ]
230 |                     );
231 |                     $args['passthroughVars'] = $passthrough;
232 |                     break;
233 |             }
234 |         }
235 | 
236 |         return $args;
237 |     }
238 | 
239 |     /**
240 |      * @return array
241 |      */
242 |     protected function getEntityFormOptions()
243 |     {
244 |         $updateSelect = ($this->request->getMethod() == 'POST')
245 |             ? $this->request->request->get('sqlConditions[updateSelect]', false, true)
246 |             : $this->request->get(
247 |                 'updateSelect',
248 |                 false
249 |             );
250 |         if ($updateSelect) {
251 |             return ['update_select' => $updateSelect];
252 |         }
253 |     }
254 | 
255 |     /**
256 |      * Return array of options update select response.
257 |      *
258 |      * @param string $updateSelect HTML id of the select
259 |      * @param object $entity
260 |      * @param string $nameMethod   name of the entity method holding the name
261 |      * @param string $groupMethod  name of the entity method holding the select group
262 |      *
263 |      * @return array
264 |      */
265 |     protected function getUpdateSelectParams($updateSelect, $entity, $nameMethod = 'getName', $groupMethod = 'getLanguage')
266 |     {
267 |         $options = [
268 |             'updateSelect' => $updateSelect,
269 |             'id'           => $entity->getId(),
270 |             'name'         => $entity->$nameMethod(),
271 |         ];
272 | 
273 |         return $options;
274 |     }
275 | }
276 | 


--------------------------------------------------------------------------------
/Entity/SqlConditions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * @copyright   2019 Mautic Contributors. All rights reserved
  5 |  * @author      Mautic
  6 |  *
  7 |  * @link        http://mautic.org
  8 |  *
  9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 10 |  */
 11 | 
 12 | namespace MauticPlugin\MauticSqlConditionsBundle\Entity;
 13 | 
 14 | use Doctrine\DBAL\Types\Type;
 15 | use Doctrine\ORM\Mapping as ORM;
 16 | use Mautic\ApiBundle\Serializer\Driver\ApiMetadataDriver;
 17 | use Mautic\CoreBundle\Doctrine\Mapping\ClassMetadataBuilder;
 18 | use Mautic\CoreBundle\Entity\FormEntity;
 19 | 
 20 | /**
 21 |  * Class SqlConditions
 22 |  *
 23 |  * @package MauticPlugin\MauticSqlConditionsBundle\Entity
 24 |  */
 25 | class SqlConditions extends FormEntity
 26 | {
 27 |     /**
 28 |      * @var int
 29 |      */
 30 |     protected $id;
 31 | 
 32 |     /**
 33 |      * @var \Mautic\CategoryBundle\Entity\Category
 34 |      **/
 35 |     private $category;
 36 | 
 37 | 
 38 |     /**
 39 |      * @var \DateTime
 40 |      */
 41 |     protected $dateAdded;
 42 | 
 43 |     /**
 44 |      * @var string
 45 |      */
 46 |     protected $name;
 47 | 
 48 |     /*
 49 |      * @vart string
 50 |      */
 51 |     protected $sqlQuery;
 52 | 
 53 | 
 54 |     public function __construct()
 55 |     {
 56 |         $this->setDateAdded(new \DateTime());
 57 |     }
 58 | 
 59 |     /**
 60 |      * @param ORM\ClassMetadata $metadata
 61 |      */
 62 |     public static function loadMetadata(ORM\ClassMetadata $metadata)
 63 |     {
 64 |         $builder = new ClassMetadataBuilder($metadata);
 65 |         $builder->setTable('sql_conditions')
 66 |             ->setCustomRepositoryClass(SqlConditionsRepository::class);
 67 |         $builder->addIdColumns('name', '');
 68 |         $builder->addNamedField('sqlQuery', Type::TEXT, 'sql_query');
 69 |         $builder->addCategory();
 70 |     }
 71 | 
 72 | 
 73 |     /**
 74 |      * Prepares the metadata for API usage.
 75 |      *
 76 |      * @param $metadata
 77 |      */
 78 |     public static function loadApiMetadata(ApiMetadataDriver $metadata)
 79 |     {
 80 |         $metadata->setGroupPrefix('sqlConditions')
 81 |             ->addListProperties(
 82 |                 [
 83 |                     'id',
 84 |                     'name',
 85 |                     'sqlQuery',
 86 |                     'category',
 87 |                     'dateAdded',
 88 |                 ]
 89 |             )
 90 |             ->build();
 91 |     }
 92 | 
 93 | 
 94 |     /**
 95 |      * Get id.
 96 |      *
 97 |      * @return int
 98 |      */
 99 |     public function getId()
100 |     {
101 |         return $this->id;
102 |     }
103 | 
104 |     /*
105 |      * Set dateAdded.
106 |      *
107 |      * @param \DateTime $dateAdded
108 |      *
109 |      * @return LeadEventLog
110 |      */
111 |     public function setDateAdded($dateAdded)
112 |     {
113 |         $this->dateAdded = $dateAdded;
114 | 
115 |         return $this;
116 |     }
117 | 
118 |     /**
119 |      * Get dateAdded.
120 |      *
121 |      * @return \DateTime
122 |      */
123 |     public function getDateAdded()
124 |     {
125 |         return $this->dateAdded;
126 |     }
127 | 
128 | 
129 |     public function getCreatedBy()
130 |     {
131 | 
132 |     }
133 | 
134 |     public function getHeader()
135 |     {
136 | 
137 |     }
138 | 
139 |     public function getPublishStatus()
140 |     {
141 | 
142 |     }
143 | 
144 |     /**
145 |      * @param string $name
146 |      *
147 |      * @return SqlConditions
148 |      */
149 |     public function setName($name)
150 |     {
151 |         $this->name = $name;
152 | 
153 |         return $this;
154 | }
155 | 
156 |     /**
157 |      * @return string
158 |      */
159 |     public function getName()
160 |     {
161 |         return $this->name;
162 |     }
163 | 
164 |     /**
165 |      * @param mixed $sqlQuery
166 |      *
167 |      * @return SqlConditions
168 |      */
169 |     public function setSqlQuery($sqlQuery)
170 |     {
171 |         $this->sqlQuery = $sqlQuery;
172 | 
173 |         return $this;
174 |     }
175 | 
176 |     /**
177 |      * @return mixed
178 |      */
179 |     public function getSqlQuery()
180 |     {
181 |         return $this->sqlQuery;
182 |     }
183 | 
184 | 
185 |     /**
186 |      * @return \Mautic\CategoryBundle\Entity\Category
187 |      */
188 |     public function getCategory()
189 |     {
190 |         return $this->category;
191 |     }
192 | 
193 |     /**
194 |      * @param \Mautic\CategoryBundle\Entity\Category $category
195 |      *
196 |      * @return $this
197 |      */
198 |     public function setCategory($category)
199 |     {
200 |         $this->category = $category;
201 | 
202 |         return $this;
203 |     }
204 | }
205 | 


--------------------------------------------------------------------------------
/Entity/SqlConditionsRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Entity;
13 | 
14 | use Mautic\CoreBundle\Entity\CommonRepository;
15 | 
16 | /**
17 |  * Class SqlConditionsRepository
18 |  * @package MauticPlugin\MauticSqlConditionsBundle\Entity
19 |  */
20 | class SqlConditionsRepository extends CommonRepository
21 | {
22 |     /**
23 |      * @param $alias
24 |      *
25 |      * @return object|null
26 |      */
27 |     public function findOneByAlias($alias)
28 |     {
29 |         return parent::findOneBy(['alias'=>$alias], null);
30 |     }
31 | 
32 |     /**
33 |      * Get a list of entities.
34 |      *
35 |      * @param array $args
36 |      *
37 |      * @return Paginator
38 |      */
39 |     public function getEntities(array $args = [])
40 |     {
41 |         $alias = $this->getTableAlias();
42 | 
43 |         $q = $this->_em
44 |             ->createQueryBuilder()
45 |             ->select($alias)
46 |             ->from('MauticSqlConditionsBundle:SqlConditions', $alias, $alias.'.id');
47 | 
48 |         if (empty($args['iterator_mode'])) {
49 |             $q->leftJoin($alias.'.category', 'c');
50 |         }
51 | 
52 |         $args['qb'] = $q;
53 | 
54 |         return parent::getEntities($args);
55 |     }
56 | 
57 | }
58 | 


--------------------------------------------------------------------------------
/Event/SqlConditionsEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Event;
13 | 
14 | use Mautic\CoreBundle\Event\CommonEvent;
15 | use MauticPlugin\MauticSqlConditionsBundle\Entity\SqlConditions;
16 | 
17 | class SqlConditionsEvent extends CommonEvent
18 | {
19 |     /**
20 |      * SqlConditionsEvent constructor.
21 |      *
22 |      * @param SqlConditions $entity
23 |      * @param bool                $isNew
24 |      */
25 |     public function __construct(SqlConditions $entity, $isNew = false)
26 |     {
27 |         $this->entity = $entity;
28 |         $this->isNew  = $isNew;
29 |     }
30 | 
31 |     /**
32 |      * @return SqlConditions
33 |      */
34 |     public function getEntity()
35 |     {
36 |         return $this->entity;
37 |     }
38 | 
39 |     /**
40 |      * @param SqlConditions $entity
41 |      */
42 |     public function setEntity(SqlConditions $entity)
43 |     {
44 |         $this->entity = $entity;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/EventListener/CampaignConditionSubscriber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2016 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic, Inc.
 6 |  *
 7 |  * @link        https://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\EventListener;
13 | 
14 | use Mautic\CampaignBundle\CampaignEvents;
15 | use Mautic\CampaignBundle\Event\CampaignBuilderEvent;
16 | use Mautic\CampaignBundle\Event\ConditionEvent;
17 | use MauticPlugin\MauticSqlConditionsBundle\Executioner\SqlExecutioner;
18 | use MauticPlugin\MauticSqlConditionsBundle\Form\Type\SqlConditionsCampaignType;
19 | use MauticPlugin\MauticSqlConditionsBundle\Form\Type\SqlListType;
20 | use MauticPlugin\MauticSqlConditionsBundle\SqlConditionsEvents;
21 | use Symfony\Component\EventDispatcher\EventSubscriberInterface;
22 | 
23 | /**
24 |  * Class CampaignConditionSubscriber.
25 |  */
26 | class CampaignConditionSubscriber implements EventSubscriberInterface
27 | {
28 | 
29 |     /**
30 |      * @var SqlExecutioner
31 |      */
32 |     private $sqlExecutioner;
33 | 
34 |     /**
35 |      * CampaignConditionSubscriber constructor.
36 |      *
37 |      * @param SqlExecutioner $sqlExecutioner
38 |      */
39 |     public function __construct(SqlExecutioner $sqlExecutioner)
40 |     {
41 |         $this->sqlExecutioner = $sqlExecutioner;
42 |     }
43 | 
44 |     /**
45 |      * @return array
46 |      */
47 |     public static function getSubscribedEvents()
48 |     {
49 |         return [
50 |             CampaignEvents::CAMPAIGN_ON_BUILD                  => ['onCampaignBuild', 0],
51 |             SqlConditionsEvents::ON_CAMPAIGN_CONDITION_TRIGGER => ['onCampaignTriggerCondition', 0],
52 |         ];
53 |     }
54 | 
55 |     /**
56 |      * @param CampaignBuilderEvent $event
57 |      */
58 |     public function onCampaignBuild(CampaignBuilderEvent $event)
59 |     {
60 |         $event->addCondition(
61 |             'sql.condition',
62 |             [
63 |                 'label'           => 'mautic.sqlConditions',
64 |                 'eventName'       => SqlConditionsEvents::ON_CAMPAIGN_CONDITION_TRIGGER,
65 |                 'formType'        => SqlConditionsCampaignType::class,
66 |                 'formTheme'       => 'MauticSqlConditionsBundle:FormTheme\SqlConditionsList',
67 |                 'formTypeOptions' => ['update_select' => 'campaignevent_properties_sql'],
68 | 
69 |             ]
70 |         );
71 |     }
72 | 
73 |     /**
74 |      * @param ConditionEvent $event
75 |      */
76 |     public function onCampaignTriggerCondition(ConditionEvent $event)
77 |     {
78 |         if ($this->sqlExecutioner->execute($event)) {
79 |             $event->pass();
80 |         } else {
81 |             $event->fail();
82 |         }
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/Executioner/Params/Params.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Executioner\Params;
13 | 
14 | use MauticPlugin\MauticSqlConditionsBundle\Executioner\SqlConditionDetails;
15 | 
16 | class Params
17 | {
18 |     /**
19 |      * @var SqlConditionDetails
20 |      */
21 |     private $sqlConditionDetails;
22 | 
23 |     /**
24 |      * @param SqlConditionDetails $sqlConditionDetails
25 |      *
26 |      * @return array
27 |      * @throws \Exception
28 |      */
29 |     public function parseParamsFromSqlQuery(SqlConditionDetails $sqlConditionDetails)
30 |     {
31 |         $this->sqlConditionDetails = $sqlConditionDetails;
32 |         $sqlQuery                  = $this->sqlConditionDetails->getSqlQuery();
33 |         $params                    = [];
34 | 
35 |         foreach ($this->getAllParams() as $key => $value) {
36 |             if (strpos($sqlQuery, $key) !== false) {
37 |                 $params[$key] = $value;
38 |             }
39 |         }
40 | 
41 |         return $params;
42 | 
43 |     }
44 | 
45 |     /**
46 |      * @return array
47 |      * @throws \Exception
48 |      */
49 |     private function getAllParams()
50 |     {
51 | 
52 |         $params                = [];
53 |         $params[':contactId']  = $this->sqlConditionDetails->getConditionEvent()->getLead()->getId();
54 |         $params[':campaignId'] = $this->sqlConditionDetails->getConditionEvent()->getLogEntry()->getCampaign()->getId();
55 |         $params[':eventId']    = $this->sqlConditionDetails->getConditionEvent()->getEvent()['id'];
56 |         $params[':rotation']   = $this->sqlConditionDetails->getConditionEvent()->getLogEntry()->getRotation();
57 | 
58 |         return $params;
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/Executioner/QueryBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Executioner;
13 | 
14 | use Doctrine\DBAL\Connections\MasterSlaveConnection;
15 | use Doctrine\ORM\EntityManager;
16 | use MauticPlugin\MauticSqlConditionsBundle\Executioner\Params\Params;
17 | 
18 | class QueryBuilder
19 | {
20 |     /**
21 |      * @var EntityManager
22 |      */
23 |     private $entityManager;
24 | 
25 |     /**
26 |      * @var \Doctrine\DBAL\Connection
27 |      */
28 |     private $connection;
29 | 
30 |     /**
31 |      * @var Params
32 |      */
33 |     private $params;
34 | 
35 |     /**
36 |      * SqlExecutioner constructor.
37 |      *
38 |      * @param EntityManager $entityManager
39 |      * @param Params        $params
40 |      */
41 |     public function __construct(EntityManager $entityManager, Params $params)
42 |     {
43 |         $this->entityManager = $entityManager;
44 |         $this->params = $params;
45 | 
46 |         /** @var Connection $connection */
47 |         $this->connection = $this->entityManager->getConnection();
48 |         if ($this->connection instanceof MasterSlaveConnection) {
49 |             $this->connection->connect('slave');
50 |         }
51 |     }
52 | 
53 |     /**
54 |      * @param SqlConditionDetails $sqlConditionDetails
55 |      *
56 |      * @return \Doctrine\DBAL\Driver\Statement
57 |      * @throws \Doctrine\DBAL\DBALException
58 |      */
59 |     public function runQuery(SqlConditionDetails $sqlConditionDetails)
60 |     {
61 |         $sqlQuery = $sqlConditionDetails->getSqlQuery();
62 |         if (!$sqlQuery) {
63 |             return false;
64 |         }
65 | 
66 |         $params = $this->params->parseParamsFromSqlQuery($sqlConditionDetails);
67 |         return $this->connection->executeQuery($sqlQuery, $params)->fetchAll();
68 |     }
69 | 
70 | 
71 | };
72 | 


--------------------------------------------------------------------------------
/Executioner/SqlConditionDetails.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Executioner;
13 | 
14 | use Mautic\CampaignBundle\Event\ConditionEvent;
15 | use MauticPlugin\MauticSqlConditionsBundle\Model\SqlConditionsModel;
16 | 
17 | class SqlConditionDetails
18 | {
19 |     /**
20 |      * @var SqlConditionsModel
21 |      */
22 |     private $sqlConditionsModel;
23 | 
24 |     /**
25 |      * @var ConditionEvent
26 |      */
27 |     private $conditionEvent;
28 | 
29 |     /**
30 |      * SqlCondition constructor.
31 |      *
32 |      * @param SqlConditionsModel $sqlConditionsModel
33 |      */
34 |     public function __construct(SqlConditionsModel $sqlConditionsModel)
35 |     {
36 |         $this->sqlConditionsModel = $sqlConditionsModel;
37 |     }
38 | 
39 |     /**
40 |      * @param ConditionEvent $conditionEvent
41 |      */
42 |     public function setConditionEvent(ConditionEvent $conditionEvent)
43 |     {
44 |         $this->conditionEvent = $conditionEvent;
45 |     }
46 | 
47 | 
48 |     /**
49 |      * @return ConditionEvent
50 |      * @throws \Exception
51 |      */
52 |     public function getConditionEvent()
53 |     {
54 |         if (!$this->conditionEvent) {
55 |             throw new \Exception('Condition event not exist');
56 |         }
57 | 
58 |         return $this->conditionEvent;
59 |     }
60 | 
61 |     /**
62 |      * @return mixed
63 |      * @throws \Exception
64 |      */
65 |     public function getSqlQuery()
66 |     {
67 |         $sqlConditionId = $this->getConditionEvent()->getConfig()['sql'];
68 |         $entity =  $this->sqlConditionsModel->getEntity($sqlConditionId);
69 | 
70 |         if ($entity && $entity->isPublished()) {
71 |             return $entity->getSqlQuery();
72 |         }
73 | 
74 |     }
75 | 
76 | }
77 | 


--------------------------------------------------------------------------------
/Executioner/SqlExecutioner.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Executioner;
13 | 
14 | use Mautic\CampaignBundle\Event\ConditionEvent;
15 | 
16 | class SqlExecutioner
17 | {
18 |     /**
19 |      * @var SqlConditionDetails
20 |      */
21 |     private $sqlConditionDetails;
22 | 
23 |     /**
24 |      * @var QueryBuilder
25 |      */
26 |     private $queryBuilder;
27 | 
28 |     /**
29 |      * SqlExecutioner constructor.
30 |      *
31 |      * @param SqlConditionDetails $sqlConditionDetails
32 |      * @param QueryBuilder        $queryBuilder
33 |      */
34 |     public function __construct(SqlConditionDetails $sqlConditionDetails, QueryBuilder $queryBuilder)
35 |     {
36 |         $this->sqlConditionDetails = $sqlConditionDetails;
37 |         $this->queryBuilder = $queryBuilder;
38 |     }
39 | 
40 |     /**
41 |      * @param ConditionEvent $conditionEvent
42 |      *
43 |      * @return bool
44 |      * @throws \Doctrine\DBAL\DBALException
45 |      */
46 |     public function execute(ConditionEvent $conditionEvent)
47 |     {
48 |         $this->sqlConditionDetails->setConditionEvent($conditionEvent);
49 |         return $this->queryBuilder->runQuery($this->sqlConditionDetails);
50 | 
51 |     }
52 | 
53 | }
54 | 


--------------------------------------------------------------------------------
/Form/Type/SqlConditionsCampaignType.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * @copyright   2019 Mautic Contributors. All rights reserved
  5 |  * @author      Mautic
  6 |  *
  7 |  * @link        http://mautic.org
  8 |  *
  9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 10 |  */
 11 | 
 12 | namespace MauticPlugin\MauticSqlConditionsBundle\Form\Type;
 13 | 
 14 | use MauticPlugin\MauticSqlConditionsBundle\Validator\Constraint\UrlDnsConstraint;
 15 | use Symfony\Component\Form\AbstractType;
 16 | use Symfony\Component\Form\Extension\Core\Type\ButtonType;
 17 | use Symfony\Component\Form\FormBuilderInterface;
 18 | use Symfony\Component\OptionsResolver\OptionsResolver;
 19 | use Symfony\Component\Routing\RouterInterface;
 20 | use Symfony\Component\Validator\Constraints\NotBlank;
 21 | 
 22 | class SqlConditionsCampaignType extends AbstractType
 23 | {
 24 |     /**
 25 |      * @var RouterInterface
 26 |      */
 27 |     protected $router;
 28 | 
 29 |     /**
 30 |      * @param RouterInterface $router
 31 |      */
 32 |     public function __construct(RouterInterface $router)
 33 |     {
 34 |         $this->router = $router;
 35 |     }
 36 | 
 37 | 
 38 |     /**
 39 |      * @param FormBuilderInterface $builder
 40 |      * @param array                $options
 41 |      */
 42 |     public function buildForm(FormBuilderInterface $builder, array $options)
 43 |     {
 44 | 
 45 |         $builder->add(
 46 |             'sql',
 47 |             SqlListType::class,
 48 |             [
 49 |                 'label'      => 'mautic.sqlConditions.sql',
 50 |                 'label_attr' => ['class' => 'control-label'],
 51 |                 'attr'       => [
 52 |                     'class'    => 'form-control',
 53 |                     'onchange' => 'Mautic.disabledSqlConditionsActions()',
 54 |                 ],
 55 |                 'multiple'    => false,
 56 |                 'required'    => true,
 57 |                 'constraints' => [
 58 |                     new NotBlank(),
 59 |                 ],
 60 |             ]
 61 |         );
 62 | 
 63 | 
 64 | 
 65 |         if (!empty($options['update_select'])) {
 66 |             $windowUrl = $this->router->generate(
 67 |                 'mautic_sqlConditions_action',
 68 |                 [
 69 |                     'objectAction' => 'new',
 70 |                     'contentOnly'  => 1,
 71 |                     'updateSelect' => $options['update_select'],
 72 |                 ]
 73 |             );
 74 | 
 75 |             $builder->add(
 76 |                 'newButton',
 77 |                 ButtonType::class,
 78 |                 [
 79 |                     'attr' => [
 80 |                         'class'   => 'btn btn-primary btn-nospin',
 81 |                         'onclick' => 'Mautic.loadNewWindow({
 82 |                         "windowUrl": "'.$windowUrl.'"
 83 |                     })',
 84 |                         'icon' => 'fa fa-plus',
 85 |                     ],
 86 |                     'label' => 'mautic.core.form.add',
 87 |                 ]
 88 |             );
 89 | 
 90 |             // create button edit focus
 91 |             $windowUrlEdit = $this->router->generate(
 92 |                 'mautic_sqlConditions_action',
 93 |                 [
 94 |                     'objectAction' => 'edit',
 95 |                     'objectId'     => 'objectId',
 96 |                     'contentOnly'  => 1,
 97 |                     'updateSelect' => $options['update_select'],
 98 |                 ]
 99 |             );
100 | 
101 |             $builder->add(
102 |                 'editButton',
103 |                 ButtonType::class,
104 |                 [
105 |                     'attr' => [
106 |                         'class'    => 'btn btn-primary btn-nospin',
107 |                         'onclick'  => 'Mautic.loadNewWindow(Mautic.standardSqlConditionsUrl({"windowUrl": "'.$windowUrlEdit.'"}))',
108 |                         'disabled' => !isset($options['data']['sql']),
109 |                         'icon'     => 'fa fa-edit',
110 |                     ],
111 |                     'label' => 'mautic.core.form.edit',
112 |                 ]
113 |             );
114 |         }
115 |         
116 |     }
117 | 
118 | 
119 |     /**
120 |      * @param OptionsResolver $resolver
121 |      */
122 |     public function configureOptions(OptionsResolver $resolver)
123 |     {
124 |         $resolver->setDefined(['update_select']);
125 |     }
126 | 
127 |     /**
128 |      * @return string
129 |      */
130 |     public function getBlockPrefix()
131 |     {
132 |         return 'sqlconditions_list';
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------
/Form/Type/SqlConditionsType.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * @copyright   2019 Mautic Contributors. All rights reserved
  5 |  * @author      Mautic
  6 |  *
  7 |  * @link        http://mautic.org
  8 |  *
  9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 10 |  */
 11 | 
 12 | namespace MauticPlugin\MauticSqlConditionsBundle\Form\Type;
 13 | 
 14 | use Mautic\CategoryBundle\Form\Type\CategoryListType;
 15 | use Mautic\CoreBundle\Form\Type\FormButtonsType;
 16 | use Mautic\CoreBundle\Form\Type\YesNoButtonGroupType;
 17 | use MauticPlugin\MauticSqlConditionsBundle\Validator\Constraint\UrlDnsConstraint;
 18 | use Symfony\Component\Form\AbstractType;
 19 | use Symfony\Component\Form\Extension\Core\Type\HiddenType;
 20 | use Symfony\Component\Form\Extension\Core\Type\TextareaType;
 21 | use Symfony\Component\Form\Extension\Core\Type\TextType;
 22 | use Symfony\Component\Form\FormBuilderInterface;
 23 | use Symfony\Component\OptionsResolver\OptionsResolver;
 24 | use Symfony\Component\OptionsResolver\OptionsResolverInterface;
 25 | use Symfony\Component\Validator\Constraints\NotBlank;
 26 | 
 27 | class SqlConditionsType extends AbstractType
 28 | {
 29 |     /**
 30 |      * @param FormBuilderInterface $builder
 31 |      * @param array                $options
 32 |      */
 33 |     public function buildForm(FormBuilderInterface $builder, array $options)
 34 |     {
 35 | 
 36 |         $builder->add(
 37 |             'name',
 38 |             TextType::class,
 39 |             [
 40 |                 'label'       => 'mautic.core.name',
 41 |                 'label_attr'  => ['class' => 'control-label'],
 42 |                 'attr'        => ['class' => 'form-control'],
 43 |                 'constraints' => [
 44 |                     new NotBlank(),
 45 |                 ],
 46 |             ]
 47 |         );
 48 | 
 49 |         $builder->add(
 50 |             'sqlQuery',
 51 |             TextareaType::class,
 52 |             [
 53 |                 'label'       => 'mautic.sqlConditions.sql',
 54 |                 'label_attr'  => ['class' => 'control-label'],
 55 |                 'attr'        => [
 56 |                     'class' => 'form-control',
 57 |                     'rows' => 5,
 58 |                 ],
 59 |                 'required'    => true,
 60 |                 'constraints' => [
 61 |                     new NotBlank(),
 62 |                 ],
 63 |             ]
 64 |         );
 65 | 
 66 |         $builder->add(
 67 |             'category',
 68 |             CategoryListType::class,
 69 |             [
 70 |                 'bundle' => 'plugin:sqlConditions',
 71 |             ]
 72 |         );
 73 | 
 74 |         $builder->add('isPublished', YesNoButtonGroupType::class);
 75 | 
 76 | 
 77 |         if (!empty($options['update_select'])) {
 78 |             $builder->add(
 79 |                 'buttons',
 80 |                 FormButtonsType::class,
 81 |                 [
 82 |                     'apply_text'        => false,
 83 |                 ]
 84 |             );
 85 |             $builder->add(
 86 |                 'updateSelect',
 87 |                 HiddenType::class,
 88 |                 [
 89 |                     'data'   => $options['update_select'],
 90 |                     'mapped' => false,
 91 |                 ]
 92 |             );
 93 |         } else {
 94 |             $builder->add(
 95 |                 'buttons',
 96 |                 FormButtonsType::class
 97 |             );
 98 |         }
 99 |     }
100 | 
101 | 
102 |     public function configureOptions(OptionsResolver $resolver)
103 |     {
104 |         $resolver->setDefaults(
105 |             [
106 |                 'data_class' => 'MauticPlugin\MauticSqlConditionsBundle\Entity\SqlConditions',
107 |             ]
108 |         );
109 |         $resolver->setDefined(['update_select']);
110 | 
111 |     }
112 | 
113 | 
114 | 
115 |     /**
116 |      * @return string
117 |      */
118 |     public function getBlockPrefix()
119 |     {
120 |         return 'sqlConditions';
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/Form/Type/SqlListType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Form\Type;
13 | 
14 | use Mautic\CoreBundle\Form\Type\EntityLookupType;
15 | use Symfony\Component\Form\AbstractType;
16 | use Symfony\Component\OptionsResolver\Options;
17 | use Symfony\Component\OptionsResolver\OptionsResolver;
18 | 
19 | class  SqlListType extends AbstractType
20 | {
21 |     /**
22 |      * {@inheritdoc}
23 |      */
24 |     public function configureOptions(OptionsResolver $resolver)
25 |     {
26 |         $resolver->setDefaults(
27 |             [
28 |                 'modal_route'         => 'mautic_sqlConditions_action',
29 |                 'modal_header'        => 'mautic.core.new',
30 |                 'model'               => 'sqlConditions',
31 |                 'model_lookup_method' => 'getLookupResults',
32 |                 'lookup_arguments'    => function (Options $options) {
33 |                     return [
34 |                         'type'    => 'sqlConditions',
35 |                         'filter'  => '$data',
36 |                         'limit'   => 0,
37 |                         'start'   => 0,
38 |                         'options' => [
39 |                             'sqlConditions_type' => $options['sqlConditions_type'],
40 |                         ],
41 |                     ];
42 |                 },
43 |                 'ajax_lookup_action' => function (Options $options) {
44 |                     $query = [
45 |                         'sqlConditions_type' => $options['sqlConditions_type'],
46 |                     ];
47 | 
48 |                     return 'sqlConditions:getLookupChoiceList&'.http_build_query($query);
49 |                 },
50 |                 'multiple' => true,
51 |                 'required' => false,
52 |                 'sqlConditions_type' => 'template',
53 |             ]
54 |         );
55 |     }
56 |     /**
57 |      * @return string
58 |      */
59 |     public function getParent()
60 |     {
61 |         return EntityLookupType::class;
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/Integration/SqlConditionsIntegration.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 
  4 | /*
  5 |  * @copyright   2019 Mautic Contributors. All rights reserved
  6 |  * @author      Mautic
  7 |  *
  8 |  * @link        http://mautic.org
  9 |  *
 10 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 11 |  */
 12 | 
 13 | namespace MauticPlugin\MauticSqlConditionsBundle\Integration;
 14 | 
 15 | use Mautic\PluginBundle\Integration\AbstractIntegration;
 16 | 
 17 | /**
 18 |  * Class SqlConditionsIntegration.
 19 |  */
 20 | class SqlConditionsIntegration extends AbstractIntegration
 21 | {
 22 | 
 23 |     /**
 24 |      * {@inheritdoc}
 25 |      *
 26 |      * @return string
 27 |      */
 28 |     public function getName()
 29 |     {
 30 |         return 'SqlConditions';
 31 |     }
 32 | 
 33 |     public function getIcon()
 34 |     {
 35 |         return 'plugins/MauticSqlConditionsBundle/Assets/img/icon.png';
 36 |     }
 37 | 
 38 |     public function getSecretKeys()
 39 |     {
 40 |         return ['password'];
 41 |     }
 42 | 
 43 |     /**
 44 |      * {@inheritdoc}
 45 |      *
 46 |      * @return array
 47 |      */
 48 |     public function getRequiredKeyFields()
 49 |     {
 50 |         return [
 51 |         ];
 52 |     }
 53 | 
 54 |     /**
 55 |      * @return array
 56 |      */
 57 |     public function getFormSettings()
 58 |     {
 59 |         return [
 60 |             'requires_callback'      => false,
 61 |             'requires_authorization' => false,
 62 |         ];
 63 |     }
 64 | 
 65 |     /**
 66 |      * {@inheritdoc}
 67 |      *
 68 |      * @return string
 69 |      */
 70 |     public function getAuthenticationType()
 71 |     {
 72 |         return 'none';
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return bool
 77 |      */
 78 |     public function isEnabledIntegration()
 79 |     {
 80 |         if (strpos($this->pathsHelper->getSystemPath('local_config'), 'local.php') !== false) {
 81 |             return true;
 82 |         }
 83 | 
 84 |         return false;
 85 |     }
 86 | 
 87 |     /**
 88 |      * @return \Mautic\PluginBundle\Entity\Integration
 89 |      */
 90 |     public function getIntegrationSettings()
 91 |     {
 92 |         $integrationSettings = parent::getIntegrationSettings();
 93 |         if (!$this->isEnabledIntegration()) {
 94 |             $integrationSettings->setIsPublished(false);
 95 |         }
 96 | 
 97 |         return $integrationSettings;
 98 |     }
 99 | 
100 |     /**
101 |      * @param \Mautic\PluginBundle\Integration\Form|\Symfony\Component\Form\FormBuilder $builder
102 |      * @param array                                                                     $data
103 |      * @param string                                                                    $formArea
104 |      */
105 |     public function appendToForm(&$builder, $data, $formArea)
106 |     {
107 |         if ($formArea == 'features') {
108 |         }
109 |     }
110 | 
111 | }
112 | 


--------------------------------------------------------------------------------
/MauticSqlConditionsBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle;
13 | 
14 | use Mautic\PluginBundle\Bundle\PluginBundleBase;
15 | use MauticPlugin\MauticSqlConditionsBundle\DependencyInjection\Compiler\OverrideServiceCompilerPass;
16 | 
17 | /**
18 |  * Class MauticSqlConditionsBundle.
19 |  */
20 | class MauticSqlConditionsBundle extends PluginBundleBase
21 | {
22 | 
23 | 
24 | }
25 | 


--------------------------------------------------------------------------------
/Model/SqlConditionsModel.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * @copyright   2019 Mautic Contributors. All rights reserved
  5 |  * @author      Mautic
  6 |  *
  7 |  * @link        http://mautic.org
  8 |  *
  9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 10 |  */
 11 | 
 12 | namespace MauticPlugin\MauticSqlConditionsBundle\Model;
 13 | 
 14 | use Mautic\CoreBundle\Model\AjaxLookupModelInterface;
 15 | use Mautic\CoreBundle\Model\FormModel;
 16 | use MauticPlugin\MauticRecommenderBundle\Entity\RecommenderTemplateRepository;
 17 | use MauticPlugin\MauticSqlConditionsBundle\Entity\SqlConditions;
 18 | use MauticPlugin\MauticSqlConditionsBundle\Entity\SqlConditionsRepository;
 19 | use MauticPlugin\MauticSqlConditionsBundle\Event\SqlConditionsEvent;
 20 | use MauticPlugin\MauticSqlConditionsBundle\Form\Type\SqlConditionsType;
 21 | use MauticPlugin\MauticSqlConditionsBundle\SqlConditionsEvents;
 22 | use Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException;
 23 | 
 24 | class SqlConditionsModel extends FormModel implements AjaxLookupModelInterface
 25 | {
 26 | 
 27 |     /**
 28 |      * Retrieve the permissions base.
 29 |      *
 30 |      * @return string
 31 |      */
 32 |     public function getPermissionBase()
 33 |     {
 34 |         return 'sqlConditions:sqlConditions';
 35 |     }
 36 | 
 37 |     /**
 38 |      * {@inheritdoc}
 39 |      *
 40 |      * @return SqlConditionsRepository
 41 |      */
 42 |     public function getRepository()
 43 |     {
 44 |         /** @var RecommenderTemplateRepository $repo */
 45 |         $repo = $this->em->getRepository('MauticSqlConditionsBundle:SqlConditions');
 46 | 
 47 |         $repo->setTranslator($this->translator);
 48 | 
 49 |         return $repo;
 50 |     }
 51 | 
 52 |     /**
 53 |      * Here just so PHPStorm calms down about type hinting.
 54 |      *
 55 |      * @param null $id
 56 |      *
 57 |      * @return null|SqlConditions
 58 |      */
 59 |     public function getEntity($id = null)
 60 |     {
 61 |         if ($id === null) {
 62 |             return new SqlConditions();
 63 |         }
 64 | 
 65 |         return parent::getEntity($id);
 66 |     }
 67 | 
 68 |     /**
 69 |      * {@inheritdoc}
 70 |      *
 71 |      * @param       $entity
 72 |      * @param       $formFactory
 73 |      * @param null  $action
 74 |      * @param array $options
 75 |      *
 76 |      * @return mixed
 77 |      *
 78 |      * @throws \InvalidArgumentException
 79 |      */
 80 |     public function createForm($entity, $formFactory, $action = null, $options = [])
 81 |     {
 82 |         if (!$entity instanceof SqlConditions) {
 83 |             throw new \InvalidArgumentException('Entity must be of class Event');
 84 |         }
 85 | 
 86 |         if (!empty($action)) {
 87 |             $options['action'] = $action;
 88 |         }
 89 | 
 90 |         return $formFactory->create(SqlConditionsType::class, $entity, $options);
 91 |     }
 92 | 
 93 |     /**
 94 |      * {@inheritdoc}
 95 |      *
 96 |      * @param $action
 97 |      * @param $entity
 98 |      * @param $isNew
 99 |      * @param $event
100 |      *
101 |      * @throws \Symfony\Component\HttpKernel\Exception\MethodNotAllowedHttpException
102 |      */
103 |     protected function dispatchEvent($action, &$entity, $isNew = false, \Symfony\Component\EventDispatcher\Event $event = null)
104 |     {
105 |         if (!$entity instanceof SqlConditions) {
106 |             throw new MethodNotAllowedHttpException(['SqlConditions']);
107 |         }
108 | 
109 |         switch ($action) {
110 |             case 'pre_save':
111 |                 $name = SqlConditionsEvents::PRE_SAVE;
112 |                 break;
113 |             case 'post_save':
114 |                 $name = SqlConditionsEvents::POST_SAVE;
115 |                 break;
116 |             case 'pre_delete':
117 |                 $name = SqlConditionsEvents::PRE_DELETE;
118 |                 break;
119 |             case 'post_delete':
120 |                 $name = SqlConditionsEvents::POST_DELETE;
121 |                 break;
122 |             default:
123 |                 return null;
124 |         }
125 | 
126 |         if ($this->dispatcher->hasListeners($name)) {
127 |             if (empty($event)) {
128 |                 $event = new SqlConditionsEvent($entity, $isNew);
129 |                 $event->setEntityManager($this->em);
130 |             }
131 | 
132 |             $this->dispatcher->dispatch($name, $event);
133 | 
134 |             return $event;
135 |         } else {
136 |             return null;
137 |         }
138 |     }
139 | 
140 |     /**
141 |      * @param        $type
142 |      * @param string $filter
143 |      * @param int    $limit
144 |      * @param int    $start
145 |      * @param array  $options
146 |      *
147 |      * @return array|mixed
148 |      */
149 |     public function getLookupResults($type, $filter = '', $limit = 10, $start = 0, $options = [])
150 |     {
151 |         $results = [];
152 |         switch ($type) {
153 |             case 'sqlConditions':
154 |                 $entities = $this->getRepository()->getSimpleList();
155 | 
156 |                 foreach ($entities as $entity) {
157 |                     $results[$entity['value']] = $entity['label'];
158 |                 }
159 | 
160 |                 //sort by language
161 |                 ksort($results);
162 | 
163 |                 break;
164 |         }
165 | 
166 |         return $results;
167 |     }
168 | 
169 | }
170 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # MauticSqlConditionsBundle
 2 | 
 3 | SQL conditions for Mautic
 4 | 
 5 | ## Support
 6 | 
 7 | https://mtcextendee.com/plugins
 8 | 
 9 | ## Installation
10 | 
11 | ### Command line
12 | - `composer require mtcextendee/mautic-sql-conditions-bundle`
13 | - `php app/console mautic:plugins:reload`
14 | -  Go to /s/plugins and setup SQL Conditions
15 | 
16 | ### Manual 
17 | - Download last version https://github.com/mtcextendee/mautic-sql-conditions-bundle/releases
18 | - Unzip files to plugins/MauticSqlConditionsBundle
19 | - Clear cache (app/cache/prod/)
20 | - Go to /s/plugins/reload
21 | - Setup SQL Conditions integration
22 | 
23 | ## Usage
24 | 
25 | 1, See new item on left menu:
26 | 
27 | ![image](https://user-images.githubusercontent.com/462477/61192212-1567ed00-a6b3-11e9-971e-eb3ab3df6beb.png)
28 | 
29 | 2, Setup SQL conditions
30 | 
31 | 3, Parameters for SQL
32 | 
33 | - :contactId
34 | - :campaignId
35 | - :eventId
36 | - :rotation
37 | 
38 | 4, Condition return true If there is results
39 | 
40 | ## Examples
41 | 
42 | Condition for contacts with ID greather like 2000
43 | 
44 | `SELECT l.id FROM leads l WHERE l.id = :contactId and l.id > 2000`
45 | 
46 | ## Credits
47 | 
48 | Icons made by <a href="https://www.flaticon.com/authors/eleonor-wang" title="Eleonor Wang">Eleonor Wang</a> from <a href="https://www.flaticon.com/" 		    title="Flaticon">www.flaticon.com</a> 
49 | 


--------------------------------------------------------------------------------
/Security/Permissions/SqlConditionsPermissions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic, Inc. All rights reserved
 5 |  * @author      Mautic, Inc
 6 |  *
 7 |  * @link        https://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle\Security\Permissions;
13 | 
14 | use Mautic\CoreBundle\Security\Permissions\AbstractPermissions;
15 | use Symfony\Component\Form\FormBuilderInterface;
16 | 
17 | class SqlConditionsPermissions extends AbstractPermissions
18 | {
19 |     /**
20 |      * {@inheritdoc}
21 |      */
22 |     public function __construct($params)
23 |     {
24 |         parent::__construct($params);
25 |         $this->addExtendedPermissions('sqlConditions');
26 |     }
27 | 
28 |     /**
29 |      * {@inheritdoc}
30 |      *
31 |      * @return string|void
32 |      */
33 |     public function getName()
34 |     {
35 |         return 'sqlConditions';
36 |     }
37 | 
38 |     /**
39 |      * {@inheritdoc}
40 |      *
41 |      * @param FormBuilderInterface $builder
42 |      * @param array                $options
43 |      */
44 |     public function buildForm(FormBuilderInterface &$builder, array $options, array $data)
45 |     {
46 |         $this->addExtendedFormFields('sqlConditions', 'sqlConditions', $builder, $data);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/SqlConditionsEvents.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | namespace MauticPlugin\MauticSqlConditionsBundle;
13 | 
14 | final class SqlConditionsEvents
15 | {
16 | 
17 |     /**
18 |      * The mautic.sqlConditions_pre_save event is thrown right before a asset is persisted.
19 |      *
20 |      * The event listener receives a
21 |      * MauticPlugin\MauticSqlConditionsBundle\Event\SqlConditionsEvent instance.
22 |      *
23 |      * @var string
24 |      */
25 |     const PRE_SAVE = 'mautic.sqlConditions_pre_save';
26 | 
27 |     /**
28 |      * The mautic.sqlConditions_post_save event is thrown right after a asset is persisted.
29 |      *
30 |      * The event listener receives a
31 |      * MauticPlugin\MauticSqlConditionsBundle\Event\SqlConditionsEvent instance.
32 |      *
33 |      * @var string
34 |      */
35 |     const POST_SAVE = 'mautic.sqlConditions_post_save';
36 | 
37 |     /**
38 |      * The mautic.sqlConditions_pre_delete event is thrown prior to when a asset is deleted.
39 |      *
40 |      * The event listener receives a
41 |      * MauticPlugin\MauticSqlConditionsBundle\Event\SqlConditionsEvent instance.
42 |      *
43 |      * @var string
44 |      */
45 |     const PRE_DELETE = 'mautic.sqlConditions_pre_delete';
46 | 
47 |     /**
48 |      * The mautic.sqlConditions_post_delete event is thrown after a asset is deleted.
49 |      *
50 |      * The event listener receives a
51 |      * MauticPlugin\MauticSqlConditionsBundle\Event\SqlConditionsEvent instance.
52 |      *
53 |      * @var string
54 |      */
55 |     const POST_DELETE = 'mautic.sqlConditions_post_delete';
56 | 
57 |     /**
58 |      * The mautic.sqlConditions.on_campaign_condition_trigger event is dispatched when the campaign sql condition is executed.
59 |      *
60 |      * The event listener receives a      * Mautic\CampaignBundle\Event\CampaignExecutionEvent
61 |      *
62 |      * @var string
63 |      */
64 |     const ON_CAMPAIGN_CONDITION_TRIGGER = 'mautic.sqlConditions.on_campaign_condition_trigger';
65 | 
66 | }
67 | 


--------------------------------------------------------------------------------
/Translations/en_US/messages.ini:
--------------------------------------------------------------------------------
1 | mautic.sqlConditions="SQL conditions"
2 | mautic.sqlConditions.manage="Manage SQL conditions"
3 | mautic.sqlConditions.sql="SQL"


--------------------------------------------------------------------------------
/Views/FormTheme/SqlConditionsList/sqlConditions_list_row.html.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | echo $view['assets']->includeScript('plugins/MauticSqlConditionsBundle/Assets/js/sqlconditions.js');
12 | 
13 | ?>
14 | 
15 | <div class="row">
16 |     <div class="col-xs-12">
17 |         <?php echo $view['form']->row($form['sql']); ?>
18 |     </div>
19 |     <div class="col-xs-12 mt-lg">
20 |         <div class="mt-3">
21 |             <?php echo $view['form']->row($form['newButton']); ?>
22 |             <?php echo $view['form']->row($form['editButton']); ?>
23 |         </div>
24 |     </div>
25 | </div>


--------------------------------------------------------------------------------
/Views/Integration/form.html.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | ?>
12 | 
13 | <div class="alert alert-danger">
14 |     <?php echo $view['translator']->trans('mautic.sqlConditions.integration.disabled'); ?>
15 | </div>


--------------------------------------------------------------------------------
/Views/SqlConditions/details.html.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | 
12 | /** @var \MauticPlugin\MauticSqlConditionsBundle\Entity\SqlConditions $entity */
13 | $isEmbedded = false;
14 | if (!$isEmbedded) {
15 |     $view->extend('MauticCoreBundle:Default:content.html.php');
16 | }
17 | $view['slots']->set(
18 |     'headerTitle',
19 |     $entity->getName()
20 | );
21 | 
22 | $customButtons = [];
23 | if (!$isEmbedded) {
24 |     $view['slots']->set(
25 |         'actions',
26 |         $view->render(
27 |             'MauticCoreBundle:Helper:page_actions.html.php',
28 |             [
29 |                 'item'            => $entity,
30 |                 'customButtons'   => (isset($customButtons)) ? $customButtons : [],
31 |                 'templateButtons' => [
32 |                     'edit'   => false,
33 |                     'clone'  => false,
34 |                     'delete' => $view['security']->hasEntityAccess(
35 |                         $permissions['sqlConditions:sqlConditions:deleteown'],
36 |                         $permissions['sqlConditions:sqlConditions:deleteother'],
37 |                         $entity->getCreatedBy()
38 |                     ),
39 |                     'close'  => $view['security']->hasEntityAccess(
40 |                         $permissions['sqlConditions:sqlConditions:viewown'],
41 |                         $permissions['sqlConditions:sqlConditions:viewother'],
42 |                         $entity->getCreatedBy()
43 |                     ),
44 |                 ],
45 |                 'routeBase'       => 'sqlConditions',
46 |             ]
47 |         )
48 |     );
49 | }
50 | ?>
51 | 
52 | <!-- start: box layout -->
53 | <div class="box-layout">
54 |     <!-- left section -->
55 |     <div class="col-md-9 bg-white height-auto">
56 |         <div class="bg-auto">
57 |             <!-- page detail header -->
58 |             <div class="pr-md pl-md pt-lg pb-lg">
59 |                 <div class="box-layout">
60 |                     <div class="col-xs-10">
61 |                     </div>
62 |                 </div>
63 |             </div>
64 |             <!--/ page detail header -->
65 | 
66 |             <!--/ page detail collapseable -->
67 |         </div>
68 | 
69 |         <!--/ end: box layout -->
70 | 


--------------------------------------------------------------------------------
/Views/SqlConditions/form.html.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | $view->extend('MauticCoreBundle:FormTheme:form_simple.html.php');
12 | 
13 | ?>
14 | <?php
15 | $view['slots']->start('primaryFormContent');
16 | /** @var \MauticPlugin\MauticSqlConditionsBundle\Entity\SqlConditionsltiple $sqlConditions */
17 | $sqlConditions = $entity;
18 | $types    = ['plugins', 'themes', 'translations', 'assets'];
19 | ?>
20 | 
21 | 
22 | <div class="row">
23 |     <div class="col-md-5">
24 |         <?php echo $view['form']->row($form['name']); ?>
25 |     </div>
26 |     <div class="col-md-5">
27 |         <?php echo $view['form']->row($form['category']); ?>
28 |     </div>
29 |     <div class="col-md-2">
30 |         <?php echo $view['form']->row($form['isPublished']); ?>
31 |     </div>
32 | </div>
33 | <div class="row">
34 |     <div class="col-md-12">
35 |         <?php echo $view['form']->row($form['sqlQuery']); ?>
36 |     </div>
37 | </div>
38 | 
39 | <div class="ide">
40 |     <?php echo $view['form']->rest($form); ?>
41 | </div>
42 | 
43 | 
44 | <?php $view['slots']->stop(); ?>
45 | 
46 | 


--------------------------------------------------------------------------------
/Views/SqlConditions/index.html.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * @copyright   2019 Mautic Contributors. All rights reserved
 5 |  * @author      Mautic
 6 |  *
 7 |  * @link        http://mautic.org
 8 |  *
 9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
10 |  */
11 | $view->extend('MauticCoreBundle:Default:content.html.php');
12 | 
13 | $view['slots']->set('mauticContent', 'sqlConditions');
14 | $view['slots']->set('headerTitle', $view['translator']->trans('mautic.sqlConditions.manage'));
15 | $view['slots']->set(
16 |     'actions',
17 |     $view->render(
18 |         'MauticCoreBundle:Helper:page_actions.html.php',
19 |         [
20 |             'templateButtons' => [
21 |                 'new' => $permissions['sqlConditions:sqlConditions:create'],
22 |             ],
23 |             'routeBase' => 'sqlConditions',
24 |         ]
25 |     )
26 | );
27 | ?>
28 | <div class="panel panel-default bdr-t-wdh-0 mb-0">
29 |     <?php echo $view->render(
30 |         'MauticCoreBundle:Helper:list_toolbar.html.php',
31 |         [
32 |             'searchValue' => $searchValue,
33 |             'searchHelp'  => 'mautic.page.help.searchcommands',
34 |             'action'      => $currentRoute,
35 |         ]
36 |     ); ?>
37 |     <div class="page-list">
38 |         <?php $view['slots']->output('_content'); ?>
39 |     </div>
40 | </div>
41 | 


--------------------------------------------------------------------------------
/Views/SqlConditions/list.html.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * @copyright   2019 Mautic Contributors. All rights reserved
  5 |  * @author      Mautic
  6 |  *
  7 |  * @link        http://mautic.org
  8 |  *
  9 |  * @license     GNU/GPLv3 http://www.gnu.org/licenses/gpl-3.0.html
 10 |  */
 11 | if ($tmpl == 'index') {
 12 |     $view->extend('MauticSqlConditionsBundle:SqlConditions:index.html.php');
 13 | }
 14 | /* @var \MauticPlugin\MauticSqlConditionsBundle\Entity\SqlConditions[] $items */
 15 | ?>
 16 | <?php if (count($items)): ?>
 17 |     <div class="table-responsive page-list">
 18 |         <table class="table table-hover table-striped table-bordered msgtable-list" id="msgTable">
 19 |             <thead>
 20 |             <tr>
 21 |                 <?php
 22 |                 echo $view->render(
 23 |                     'MauticCoreBundle:Helper:tableheader.html.php',
 24 |                     [
 25 |                         'checkall'        => 'true',
 26 |                         'target'          => '#msgTable',
 27 |                         'routeBase'       => 'sqlConditions',
 28 |                         'templateButtons' => [
 29 |                             'delete' => $permissions['sqlConditions:sqlConditions:deleteown']
 30 |                                 || $permissions['sqlConditions:sqlConditions:deleteother'],
 31 |                         ],
 32 |                     ]
 33 |                 );
 34 | 
 35 |                 echo $view->render(
 36 |                     'MauticCoreBundle:Helper:tableheader.html.php',
 37 |                     [
 38 |                         'sessionVar' => 'sqlConditions',
 39 |                         'orderBy'    => 'e.name',
 40 |                         'text'       => 'mautic.core.name',
 41 |                         'class'      => 'col-msg-name',
 42 |                         'default'    => true,
 43 |                     ]
 44 |                 );
 45 | 
 46 |                 echo $view->render(
 47 |                     'MauticCoreBundle:Helper:tableheader.html.php',
 48 |                     [
 49 |                         'sessionVar' => 'sqlConditions',
 50 |                         'orderBy'    => 'c.title',
 51 |                         'text'       => 'mautic.core.category',
 52 |                         'class'      => 'visible-md visible-lg col-focus-category',
 53 |                     ]
 54 |                 );
 55 | 
 56 |                 echo $view->render(
 57 |                     'MauticCoreBundle:Helper:tableheader.html.php',
 58 |                     [
 59 |                         'sessionVar' => 'sqlConditions',
 60 |                         'orderBy'    => 'e.id',
 61 |                         'text'       => 'mautic.core.id',
 62 |                         'class'      => 'col-msg-id visible-md visible-lg',
 63 |                     ]
 64 |                 );
 65 |                 ?>
 66 |             </tr>
 67 |             </thead>
 68 |             <tbody>
 69 |             <?php foreach ($items as $item): ?>
 70 |                 <tr>
 71 |                     <td>
 72 |                         <?php
 73 |                         echo $view->render(
 74 |                             'MauticCoreBundle:Helper:list_actions.html.php',
 75 |                             [
 76 |                                 'item'            => $item,
 77 |                                 'templateButtons' => [
 78 |                                     'edit' => $view['security']->hasEntityAccess(
 79 |                                         $permissions['sqlConditions:sqlConditions:editown'],
 80 |                                         $permissions['sqlConditions:sqlConditions:editother'],
 81 |                                         $item->getCreatedBy()
 82 |                                     ),
 83 |                                     'clone'  => $permissions['sqlConditions:sqlConditions:create'],
 84 |                                     'delete' => $view['security']->hasEntityAccess(
 85 |                                         $permissions['sqlConditions:sqlConditions:deleteown'],
 86 |                                         $permissions['sqlConditions:sqlConditions:deleteother'],
 87 |                                         $item->getCreatedBy()
 88 |                                     ),
 89 |                                 ],
 90 |                                 'routeBase'  => 'sqlConditions',
 91 |                                 'nameGetter' => 'getName',
 92 |                             ]
 93 |                         );
 94 |                         ?>
 95 |                     </td>
 96 |                     <td>
 97 |                         <a href="<?php echo $view['router']->url(
 98 |                             'mautic_sqlConditions_action',
 99 |                             ['objectAction' => 'edit', 'objectId' => $item->getId()]
100 |                         ); ?>" data-toggle="ajax">
101 |                             <?php echo $item->getName(); ?>
102 | 
103 |                         </a>
104 |                     </td>
105 |                     <td class="visible-md visible-lg">
106 |                         <?php $category = $item->getCategory(); ?>
107 |                         <?php $catName  = ($category) ? $category->getTitle() : $view['translator']->trans('mautic.core.form.uncategorized'); ?>
108 |                         <?php $color    = ($category) ? '#'.$category->getColor() : 'inherit'; ?>
109 |                         <span style="white-space: nowrap;"><span class="label label-default pa-4" style="border: 1px solid #d5d5d5; background: <?php echo $color; ?>;"> </span> <span><?php echo $catName; ?></span></span>
110 |                     </td>
111 |                     <td class="visible-md visible-lg"><?php echo $item->getId(); ?></td>
112 |                 </tr>
113 |             <?php endforeach; ?>
114 |             </tbody>
115 |         </table>
116 |         <div class="panel-footer">
117 |             <?php echo $view->render(
118 |                 'MauticCoreBundle:Helper:pagination.html.php',
119 |                 [
120 |                     'totalItems' => count($items),
121 |                     'page'       => $page,
122 |                     'limit'      => $limit,
123 |                     'menuLinkId' => 'mautic_sqlConditions_event_index',
124 |                     'baseUrl'    => $view['router']->url('mautic_sqlConditions_index'),
125 |                     'sessionVar' => 'badge',
126 |                 ]
127 |             ); ?>
128 |         </div>
129 |     </div>
130 | <?php else: ?>
131 |     <?php echo $view->render('MauticCoreBundle:Helper:noresults.html.php'); ?>
132 | <?php endif; ?>
133 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "mtcextendee/mautic-sql-conditions-bundle",
3 |   "type": "mautic-plugin",
4 |   "require": {
5 |     "mautic/composer-plugin": "^1.0"
6 |   }
7 | }


--------------------------------------------------------------------------------