├── .gitignore
├── LICENSE.md
├── README.md
├── composer.json
├── event_thing
    ├── Helper
    │   └── VirtualPlugins.php
    ├── Observer
    │   ├── AbstractObserver.php
    │   ├── GenericObserver.php
    │   └── OncePerEventObserver.php
    ├── Plugin
    │   ├── GenericPlugin.php
    │   └── OncePerEntityPlugin.php
    ├── Transport
    │   ├── DummyTransport.php
    │   ├── Rest.php
    │   └── TransportInterface.php
    ├── etc
    │   ├── config.xml
    │   ├── di.xml
    │   └── module.xml
    └── registration.php
├── framework
    └── Interception
    │   └── Definition
    │       └── Runtime.php
└── gnu-gpl-v3.0.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | # License
 2 | 
 3 | ### GPLv3
 4 | 
 5 | This software is provided under the terms of [GPLv3](./gnu-gpl-v3.0.md).
 6 | 
 7 | ### Credit
 8 | 
 9 | The files in the 'framework' folder contain modified versions of code which is © Adobe.
10 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Event Thing for Magento 2
  2 | 
  3 | This module provides the functionality of "Generic Observers", "Generic Plugins" and "Transport Adapters".
  4 | 
  5 | Generic Observers & Plugins enable the logic/integration touch points of Magento Plugins & Observers to be handled 
  6 | outside the core Magento application.
  7 | 
  8 | Transport Adapters are the communication layer between Magento and the external application which processes the Generic 
  9 | Observers & Plugins.
 10 | 
 11 | ## Usage
 12 | 
 13 | ## Transport
 14 | 
 15 | **IMPORTANT:** For data security reasons, this base module **will not** send data to an external application without 
 16 | additional development. 
 17 | 
 18 | To make the code functional, a Transport Adapter implementing `\Cmtickle\EventThing\Transport\TransportInterface` is 
 19 | needed. This should be configured in global di.xml within your custom codebase.
 20 | 
 21 | An example implementation is provided for a REST API Transport. To use the REST Transport, create the following files 
 22 | in your custom module. The custom module must depend on Cmtickle_EventThing.
 23 | 
 24 | app/etc/di.xml
 25 | ```xml
 26 | <?xml version="1.0"?>
 27 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 28 |         xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
 29 |     <preference for="Cmtickle\EventThing\Transport\TransportInterface"
 30 |                 type="Cmtickle\EventThing\Transport\Rest"/>
 31 | </config>
 32 | ```
 33 | app/etc/config.xml
 34 | ```xml
 35 | <?xml version="1.0"?>
 36 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Store:etc/config.xsd">
 37 |     <default>
 38 |         <event_thing>
 39 |             <rest>
 40 |                 <url>https://your.rest.url/endpoint</url>
 41 |             </rest>
 42 |         </event_thing>
 43 |     </default>
 44 | </config>
 45 | ```
 46 | 
 47 | ## Generic Observers
 48 | 
 49 | ### IMPORTANT PRINCIPLES
 50 | 
 51 | A Generic Observer should, conceptually, be considered asynchronous. Don't rely on it running immediately, imagine that 
 52 | your observer is added to a queue.
 53 | 
 54 | A Generic Observer **MUST NOT** attempt to affect data at the runtime (it could be used to trigger an API call to 
 55 | modify data later). Use a Generic Plugin if you need to affect data at runtime.
 56 | 
 57 | Meaning, it should be possible for the Observer to run at any point in the future and treat data provided by the event 
 58 | as read-only.
 59 | 
 60 | Some possible use cases for Generic Observers:
 61 | 
 62 | * Exporting new orders to a third-party system on save.
 63 | * Notifying a third-party about failed payments/orders.
 64 | * Monitoring how many times a specific URL is viewed.
 65 | * Triggering a process which flushes an external page cache when a product goes out of stock/comes into stock.
 66 | 
 67 | ### Types of Observer supported.
 68 | 
 69 | The types of Generic Observer supported are:
 70 | 
 71 | #### Cmtickle\EventThing\Observer\AbstractObserver
 72 | 
 73 | Extend this if you want to create a new type of Observer.
 74 | 
 75 | #### Cmtickle\EventThing\Observer\GenericObserver
 76 | 
 77 | The most basic observer, will be processed every time the event fires.
 78 | 
 79 | #### Cmtickle\EventThing\Observer\OncePerEventObserver
 80 | 
 81 | Fired only once per during each run of the application (a page load normally represents a run of the application).
 82 | 
 83 | ### Adding an Observer
 84 | 
 85 | Add `events.xml` in the standard locations for Magento [see dpcumentation](https://devdocs.magento.com/guides/v2.3/ext-best-practices/extension-coding/observers-bp.html)
 86 | 
 87 | For example, to send the order data once after load:
 88 | ```xml
 89 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
 90 |     <event name="sales_order_load_after">
 91 |         <observer name="event_thing_sales_order_load_after" instance="Cmtickle\EventThing\Observer\OncePerEventObserver"/>
 92 |     </event>
 93 | </config>
 94 | ```
 95 | 
 96 | ## Generic Plugins
 97 | 
 98 | ### IMPORTANT PRINCIPLES
 99 | 
100 | As we should [avoid using the 'around' Plugin type](https://devdocs.magento.com/guides/v2.3/ext-best-practices/extension-coding/common-programming-bp.html#using-around-plugins)
101 | these are not currently supported by Event Thing.
102 | 
103 | Plugins should be used when you need to change data during runtime.
104 | 
105 | As plugins are executed during runtime, they can affect performance. Avoid slow API calls in your Plugin processing.
106 | 
107 | ### Supported Generic Plugin classes.
108 | 
109 | #### Cmtickle\EventThing\Plugin\GenericPlugin
110 | 
111 | Will process data on every occurrence of your Plugin being called.
112 | 
113 | #### Cmtickle\EventThing\Plugin\OncePerEntityPlugin
114 | 
115 | Will process your Plugin once per application run for each entity (an entity is a Product, Category, Order etc.).
116 | 
117 | ### Adding a Plugin
118 | 
119 | Each Generic Plugin needs two elements, both are added to di.xml in the standard places:
120 | * A VirtualType which declares which class of Generic Plugin to use, which class, method and Plugin type to use.
121 | * The Plugin definition itself, which refers to the VirtualType.
122 | 
123 | **IMPORTANT:** VirtualType(s) MUST be defined in global scope (etc/di.xml)
124 | 
125 | For example, to process a Generic Plugin for the Product Class on `afterGetPrice` and `afterLoad`::
126 | ```xml
127 | <?xml version="1.0"?>
128 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
129 |     <virtualType name="Cmtickle\EventThing\Plugin\Product" type="Cmtickle\EventThing\Plugin\GenericPlugin">
130 |         <arguments>
131 |             <argument name="pluggedInClass" xsi:type="string">Magento\Catalog\Model\Product</argument>
132 |             <argument name="functions" xsi:type="array">
133 |                 <item name="after" xsi:type="array">
134 |                     <item name="1" xsi:type="string">load</item>
135 |                     <item name="2" xsi:type="string">getPrice</item>
136 |                 </item>
137 |             </argument>
138 |         </arguments>
139 |     </virtualType>
140 |     
141 |     <type name="Magento\Catalog\Model\Product">
142 |         <plugin name="cmtickle_product_plugin" 
143 |                 type="Cmtickle\EventThing\Plugin\Product"/>
144 |     </type>
145 | </config>
146 | ```
147 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "cmtickle/module-event-thing",
 3 |     "description": "Magento 2 module to enable low-code/no-code Plugins and Observers",
 4 |     "type": "magento2-module",
 5 |     "license": [
 6 |         "GPLv3",
 7 |         "Proprietary"
 8 |     ],
 9 |     "require": {
10 |         "magento/framework": ">=101.0.0"
11 |     },
12 |     "autoload": {
13 |         "files": [
14 |             "event_thing/registration.php"
15 |         ],
16 |         "psr-4": {
17 |             "Magento\\Framework\\": "framework/",
18 |             "Cmtickle\\EventThing\\": "event_thing/"
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/event_thing/Helper/VirtualPlugins.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | namespace Cmtickle\EventThing\Helper;
 6 | 
 7 | use Magento\Framework\App\ObjectManager;
 8 | use Cmtickle\EventThing\Plugin\GenericPlugin;
 9 | 
10 | class VirtualPlugins
11 | {
12 |     const IDENTIFIER_CLASS = 'class';
13 |     const IDENTIFIER_VIRTUAL_TYPE = 'virtual_type';
14 |     private static ObjectManager|null $objectManager = null;
15 | 
16 |     /**
17 |      * ObjectManager is needed as this class is called statically.
18 |      * This class is only used during DI compilation.
19 |      * Therefor, application performance at runtime is not affected.
20 |      *
21 |      * @return ObjectManager
22 |      */
23 |     private static function getObjectManager():ObjectManager
24 |     {
25 |         if (null === self::$objectManager) {
26 |             self::$objectManager = ObjectManager::getInstance();
27 |         }
28 | 
29 |         return self::$objectManager;
30 |     }
31 | 
32 |     /**
33 |      * @param string $pluggedInClass
34 |      * @param string $identifier
35 |      * @return mixed
36 |      * @throws \Exception
37 |      */
38 |     public static function getDynamicVirtualPlugin(string $pluggedInClass, string $identifier):GenericPlugin
39 |     {
40 |         $config = self::getObjectManager()->get('Magento\Framework\ObjectManager\ConfigInterface');
41 |         $virtualTypes = $config->getVirtualTypes();
42 |         $virtualPlugins = [];
43 |         foreach ($virtualTypes as $virtualType => $pluggedInVirtualType) {
44 |             if (!is_a($pluggedInVirtualType, GenericPlugin::class, true)) {
45 |                 continue;
46 |             }
47 |             $virtualPlugin = self::getObjectManager()->get($virtualType);
48 |             if (self::IDENTIFIER_CLASS == $identifier && $pluggedInClass == $virtualPlugin->getPluggedInClass()) {
49 |                 $virtualPlugins[] = $virtualPlugin;
50 |             } elseif (self::IDENTIFIER_VIRTUAL_TYPE == $identifier && $virtualType == $pluggedInClass) {
51 |                 $virtualPlugins[] = $virtualPlugin;
52 |             }
53 |         }
54 |         $virtualPluginCount = count($virtualPlugins);
55 |         if(1 !== $virtualPluginCount) {
56 |             throw new \Exception('One Dynamic Virtual Plugin must be defined for ' . $pluggedInClass .
57 |                 ', ' . $virtualPluginCount . ' defined.' );
58 |         }
59 | 
60 |         return $virtualPlugins[0];
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/event_thing/Observer/AbstractObserver.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | namespace Cmtickle\EventThing\Observer;
 6 | 
 7 | use Cmtickle\EventThing\Transport\TransportInterface;
 8 | 
 9 | abstract class AbstractObserver implements \Magento\Framework\Event\ObserverInterface
10 | {
11 |     protected \Magento\Framework\HTTP\PhpEnvironment\RemoteAddress $remoteAddress;
12 |     protected \Cmtickle\EventThing\Transport\TransportInterface $transport;
13 | 
14 |     /**
15 |      * @param TransportInterface $transport
16 |      */
17 |     public function __construct(
18 |         \Magento\Framework\HTTP\PhpEnvironment\RemoteAddress $remoteAddress,
19 |         \Cmtickle\EventThing\Transport\TransportInterface $transport
20 |     ) {
21 |         $this->remoteAddress = $remoteAddress;
22 |         $this->transport = $transport;
23 |     }
24 | 
25 |     /**
26 |      * @param array $data
27 |      * @return array
28 |      */
29 |     protected function processData(array $data): array
30 |     {
31 |         $data['eventType'] = 'observer';
32 |         $data['customerIp'] = $this->remoteAddress->getRemoteAddress();
33 |         return $this->transport->process($data);
34 |     }
35 | 
36 |     /**
37 |      * @param object|string $pluggedInClass
38 |      * @return bool
39 |      */
40 |     protected function isDataObject(object|string $pluggedInClass): bool
41 |     {
42 |         return is_a($pluggedInClass, \Magento\Framework\DataObject::class, true);
43 |     }
44 | 
45 |     /**
46 |      * @param \Magento\Framework\Event\Observer $observer
47 |      * @return void
48 |      */
49 |     abstract public function execute(\Magento\Framework\Event\Observer $observer): void;
50 | }
51 | 


--------------------------------------------------------------------------------
/event_thing/Observer/GenericObserver.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | namespace Cmtickle\EventThing\Observer;
 6 | 
 7 | use Magento\Framework\Event\Observer;
 8 | 
 9 | class GenericObserver extends AbstractObserver
10 | {
11 |     /**
12 |      * @param Observer $observer
13 |      * @return void
14 |      */
15 |     public function execute(\Magento\Framework\Event\Observer $observer): void
16 |     {
17 |         $event = $observer->getEvent();
18 | 
19 |         if ($event->hasData('data_object') && $dataObject = $event->getData('data_object')) {
20 |             $data = ['eventName' => $event->getName()];
21 |             $data['dataObject'] = (
22 |                 $this->isDataObject($dataObject::class) ?
23 |                     $dataObject->toArray() :
24 |                     $event->getData()
25 |             );
26 |             $this->processData($data);
27 |         } else {
28 |             $this->processData($event->getData());
29 |         }
30 |     }
31 | 
32 | }
33 | 


--------------------------------------------------------------------------------
/event_thing/Observer/OncePerEventObserver.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | namespace Cmtickle\EventThing\Observer;
 6 | 
 7 | use Magento\Framework\Event\Observer;
 8 | 
 9 | class OncePerEventObserver extends GenericObserver
10 | {
11 |     private static array $called = [];
12 | 
13 |     /**
14 |      * @param Observer $observer
15 |      * @return void
16 |      */
17 |     public function execute(\Magento\Framework\Event\Observer $observer): void
18 |     {
19 |         $eventName = $observer->getEvent()->getName();
20 |         if (isset(self::$called[$eventName])) {
21 |             return;
22 |         }
23 | 
24 |         self::$called[$eventName] = true;
25 |         parent::execute($observer);
26 |     }
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/event_thing/Plugin/GenericPlugin.php:
--------------------------------------------------------------------------------
  1 | <?php declare(strict_types=1);
  2 | /*
  3 | * © Colin Tickle. See LICENSE for details.
  4 | */
  5 | namespace Cmtickle\EventThing\Plugin;
  6 | 
  7 | use Cmtickle\EventThing\Transport\TransportInterface;
  8 | use Magento\Framework\HTTP\PhpEnvironment\RemoteAddress;
  9 | 
 10 | class GenericPlugin
 11 | {
 12 |     protected \Magento\Framework\HTTP\PhpEnvironment\RemoteAddress $remoteAddress;
 13 |     protected \Cmtickle\EventThing\Transport\TransportInterface $transport;
 14 | 
 15 |     /**
 16 |      * key => 'before|after|around', value => ['functionName']
 17 |      * @var array[array] $functions
 18 |      */
 19 |     protected array $functions = [];
 20 |     protected array|null $pluginMethods = null;
 21 |     protected string $pluggedInClass;
 22 | 
 23 |     /**
 24 |      * @param RemoteAddress $remoteAddress
 25 |      * @param TransportInterface $transport
 26 |      * @param string $pluggedInClass
 27 |      * @param array $functions
 28 |      */
 29 |     public function __construct(
 30 |         \Magento\Framework\HTTP\PhpEnvironment\RemoteAddress $remoteAddress,
 31 |         \Cmtickle\EventThing\Transport\TransportInterface $transport,
 32 |         string $pluggedInClass,
 33 |         array $functions
 34 |     ) {
 35 |         $this->remoteAddress = $remoteAddress;
 36 |         $this->transport = $transport;
 37 |         $this->pluggedInClass = $pluggedInClass;
 38 |         $this->functions = $functions;
 39 |     }
 40 | 
 41 |     /**
 42 |      * @param $pluggedInClass
 43 |      * @return bool
 44 |      */
 45 |     protected function isDataObject($pluggedInClass): bool
 46 |     {
 47 |         return is_a($pluggedInClass, \Magento\Framework\DataObject::class, true);
 48 |     }
 49 | 
 50 |     /**
 51 |      * @param array $data
 52 |      * @return array
 53 |      */
 54 |     protected function processData(array $data): array
 55 |     {
 56 |         $data['eventType'] = 'plugin';
 57 |         $data['customerIp'] = $this->remoteAddress->getRemoteAddress();
 58 |         return $this->transport->process($data);
 59 |     }
 60 | 
 61 |     /**
 62 |      * @param $methodName
 63 |      * @param $pluggedInClass
 64 |      * @param array $arguments
 65 |      * @return array|array[]
 66 |      */
 67 |     protected function beforeFunction($methodName, $pluggedInClass, array $arguments = []): array
 68 |     {
 69 |         $data =  [
 70 |             'pluggedInClass' => $this->getPluggedInClass(),
 71 |             'pluggedInMethod' => $methodName,
 72 |             'pluginType' => 'before',
 73 |             'dataObject' => $this->isDataObject($pluggedInClass) ? $pluggedInClass->toArray() : [],
 74 |             'arguments' => $arguments
 75 |         ];
 76 |         $processed = $this->processData($data);
 77 | 
 78 |         return [$processed['arguments']];
 79 |     }
 80 | 
 81 |     /**
 82 |      * @param $methodName
 83 |      * @param $pluggedInClass
 84 |      * @param $returnedParameters
 85 |      * @return mixed
 86 |      */
 87 |     protected function afterFunction($methodName, $pluggedInClass, $returnedParameters): mixed
 88 |     {
 89 |         $data = [
 90 |             'pluggedInClass' => $this->getPluggedInClass(),
 91 |             'pluggedInMethod' => $methodName,
 92 |             'pluginType' => 'after',
 93 |             'dataObject' => $this->isDataObject($pluggedInClass) ? $pluggedInClass->getData() : [],
 94 |             'returnedParameters' => $returnedParameters
 95 |         ];
 96 |         $processed = $this->processData($data);
 97 | 
 98 |         return $processed['returnedParameters'];
 99 |     }
100 | 
101 |     /**
102 |      * @param string $name
103 |      * @param array $arguments
104 |      * @return array[]|false|mixed
105 |      */
106 |     public function __call(string $name, array $arguments)
107 |     {
108 |         switch(substr($name, 0, 5)) {
109 |             case 'after':
110 |                 return $this->afterFunction($name, ... $arguments);
111 |                 break;
112 |             case 'befor':
113 |                 $pluggedInClass = array_shift($arguments);
114 |                 $arguments = $arguments ?? [];
115 |                 return $this->beforeFunction($name, $pluggedInClass, $arguments);
116 |                 break;
117 |             default:
118 |                 return end($arguments);
119 |         }
120 |     }
121 | 
122 |     /**
123 |      * @return string
124 |      */
125 |     public function getPluggedInClass(): string
126 |     {
127 |         return $this->pluggedInClass;
128 |     }
129 | 
130 |     /**
131 |      * @return array
132 |      */
133 |     public function getPluginMethods(): array
134 |     {
135 |         if (!(null === $this->pluginMethods)) {
136 |             return $this->pluginMethods;
137 |         }
138 |         $this->pluginMethods = [];
139 |         foreach ($this->functions as $pluginType => $functions) {
140 |             foreach ($functions as $index => $function) {
141 |                 $this->pluginMethods[] = strtolower($pluginType).ucfirst($function);
142 |             }
143 |         }
144 |         return $this->pluginMethods;
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/event_thing/Plugin/OncePerEntityPlugin.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | namespace Cmtickle\EventThing\Plugin;
 6 | 
 7 | use Magento\Framework\DataObject;
 8 | 
 9 | class OncePerEntityPlugin extends GenericPlugin
10 | {
11 |     protected static array $called = [];
12 | 
13 |     /**
14 |      * @param string $name
15 |      * @param array $arguments
16 |      * @return array|array[]|false|mixed
17 |      */
18 |     public function __call(string $name, array $arguments)
19 |     {
20 |         $pluggedInClass = $arguments[0];
21 |         if ($this->isDataObject($pluggedInClass)) {
22 |             $entityId = $pluggedInClass->getData($pluggedInClass->getResource()->getIdFieldName());
23 |             $eventPrefix = $pluggedInClass->getEventPrefix();
24 |             if (!isset(self::$called[$eventPrefix . '__' . $name]) ||
25 |                 !isset(self::$called[$eventPrefix . '__' . $name][(string) $entityId])) {
26 |                 self::$called[$eventPrefix . '__' . $name][(string) $entityId] = parent::__call($name, $arguments);
27 |             }
28 |             return self::$called[$eventPrefix . '__' . $name][(string) $entityId];
29 |         } else {
30 |             return parent::__call($name, $arguments);
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/event_thing/Transport/DummyTransport.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | namespace Cmtickle\EventThing\Transport;
 6 | 
 7 | class DummyTransport implements TransportInterface
 8 | {
 9 |     public function process(array $data): array
10 |     {
11 |         return $data;
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/event_thing/Transport/Rest.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | 
 6 | namespace Cmtickle\EventThing\Transport;
 7 | 
 8 | use Magento\Framework\App\Config\ScopeConfigInterface;
 9 | use Magento\Framework\Serialize\Serializer\Json;
10 | 
11 | class Rest implements TransportInterface
12 | {
13 |     protected \Magento\Framework\App\Config\ScopeConfigInterface $scopeConfig;
14 |     protected \Magento\Framework\Serialize\Serializer\Json $serialize;
15 | 
16 |     protected bool|string $restUrl = false;
17 | 
18 |     /**
19 |      * @param ScopeConfigInterface $scopeConfig
20 |      * @param Json $serialize
21 |      */
22 |     public function __construct(
23 |         \Magento\Framework\App\Config\ScopeConfigInterface $scopeConfig,
24 |         \Magento\Framework\Serialize\Serializer\Json $serialize
25 |     ) {
26 |         $this->scopeConfig = $scopeConfig;
27 |         $this->serialize = $serialize;
28 |     }
29 | 
30 |     /**
31 |      * @return string
32 |      * @throws \Exception
33 |      */
34 |     protected function getRestUrl(): mixed
35 |     {
36 |         if (false === $this->restUrl) {
37 |             $this->restUrl = $this->scopeConfig->getValue(
38 |                 'event_thing/rest/url',
39 |                 \Magento\Store\Model\ScopeInterface::SCOPE_STORE,
40 |             );
41 |         }
42 | 
43 |         if (!$this->restUrl) {
44 |             throw new \Exception('Event Thing REST URL not defined, check documentation.');
45 |         }
46 | 
47 |         return $this->restUrl;
48 |     }
49 | 
50 |     /**
51 |      * @inheritdoc
52 |      */
53 |     public function process(array $data): array
54 |     {
55 |         $curl = curl_init($this->getRestUrl());
56 |         curl_setopt($curl, CURLOPT_HEADER, false);
57 |         curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
58 |         curl_setopt($curl, CURLOPT_HTTPHEADER,
59 |             array("Content-type: application/json"));
60 |         curl_setopt($curl, CURLOPT_TIMEOUT, 1);
61 |         curl_setopt($curl, CURLOPT_POST, true);
62 |         curl_setopt($curl, CURLOPT_POSTFIELDS, $this->serialize->serialize($data));
63 |         $response = curl_exec($curl);
64 | 
65 |         return $response ? $this->serialize->Unserialize($response) : $data;
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/event_thing/Transport/TransportInterface.php:
--------------------------------------------------------------------------------
 1 | <?php declare(strict_types=1);
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | namespace Cmtickle\EventThing\Transport;
 6 | 
 7 | interface TransportInterface
 8 | {
 9 |     /**
10 |      * Send the data to some external processing system.
11 |      * The external system
12 |      *
13 |      * @param array $data
14 |      * @return array
15 |      */
16 |     public function process(array $data):array;
17 | }
18 | 


--------------------------------------------------------------------------------
/event_thing/etc/config.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <!--
 3 |  © Colin Tickle. See LICENSE for details.
 4 | -->
 5 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Store:etc/config.xsd">
 6 |     <default>
 7 |         <event_thing>
 8 |             <rest>
 9 |                 <url></url>
10 |             </rest>
11 |         </event_thing>
12 |     </default>
13 | </config>
14 | 


--------------------------------------------------------------------------------
/event_thing/etc/di.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0"?>
 2 | <!--
 3 |  © Colin Tickle. See LICENSE for details.
 4 | -->
 5 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 6 |         xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
 7 |     <preference for="Cmtickle\EventThing\Transport\TransportInterface"
 8 |                 type="Cmtickle\EventThing\Transport\DummyTransport"/>
 9 | </config>
10 | 


--------------------------------------------------------------------------------
/event_thing/etc/module.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0"?>
2 | <!--
3 |  © Colin Tickle. See LICENSE for details.
4 | -->
5 | <config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
6 |         xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
7 |     <module name="Cmtickle_EventThing"/>
8 | </config>
9 | 


--------------------------------------------------------------------------------
/event_thing/registration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /*
 3 | * © Colin Tickle. See LICENSE for details.
 4 | */
 5 | \Magento\Framework\Component\ComponentRegistrar::register(
 6 |     \Magento\Framework\Component\ComponentRegistrar::MODULE,
 7 |     'Cmtickle_EventThing',
 8 |     __DIR__
 9 | );
10 | 


--------------------------------------------------------------------------------
/framework/Interception/Definition/Runtime.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * \Reflection based plugin method list. Uses reflection to retrieve list of interception methods defined in plugin.
  4 |  * Should be only used in development mode, because it reads method list on every request which is expensive.
  5 |  *
  6 |  * Copyright © Magento, Inc. All rights reserved.
  7 |  * See COPYING.txt for license details.
  8 |  *
  9 |  * Modifications for Event Thing © Colin Tickle. See LICENSE for details.
 10 |  */
 11 | 
 12 | namespace Magento\Framework\Interception\Definition;
 13 | 
 14 | use Cmtickle\EventThing\Plugin\GenericPlugin;
 15 | use Magento\Framework\App\Arguments\ValidationState;
 16 | use Magento\Framework\Interception\DefinitionInterface;
 17 | 
 18 | use function Safe\class_implements;
 19 | 
 20 | class Runtime implements DefinitionInterface
 21 | {
 22 |     private static array|null $backtrace = null;
 23 |     /**
 24 |      * @var array
 25 |      */
 26 |     protected $_typesByPrefixes = [
 27 |         'befor' => self::LISTENER_BEFORE,
 28 |         'aroun' => self::LISTENER_AROUND,
 29 |         'after' => self::LISTENER_AFTER,
 30 |     ];
 31 | 
 32 |     /**
 33 |      * Plugin method service prefix lengths
 34 |      *
 35 |      * @var array
 36 |      */
 37 |     protected $prefixLengths = [
 38 |         self::LISTENER_BEFORE => 6,
 39 |         self::LISTENER_AROUND => 6,
 40 |         self::LISTENER_AFTER => 5,
 41 |     ];
 42 |     protected \Cmtickle\EventThing\Helper\VirtualPlugins $virtualPlugins;
 43 | 
 44 |     public function __construct() {
 45 |         $this->virtualPlugins = new \Cmtickle\EventThing\Helper\VirtualPlugins();
 46 |     }
 47 | 
 48 |     protected function getBacktrace()
 49 |     {
 50 |         return debug_backtrace();
 51 |     }
 52 | 
 53 |     /**
 54 |      * @description : By the time this class is called, only the base class is known.
 55 |      *  This function uses the stack trace to work out the intended class for the Plugin.
 56 |      *
 57 |      * @return mixed|void
 58 |      */
 59 |     protected function getPluggedInClass()
 60 |     {
 61 |         $backtrace = $this->getBacktrace();
 62 |         foreach ($backtrace as $trace) {
 63 |             if ($trace['class'] == 'Magento\Framework\Interception\PluginListGenerator' &&
 64 |                 $trace['function'] == 'inheritPlugins') {
 65 |                 return $trace['args'][0];
 66 |             }
 67 |         }
 68 |     }
 69 | 
 70 |     protected function getDynamicClassMethods(string $pluggedInClass = '')
 71 |     {
 72 |         if (!$pluggedInClass) {
 73 |             $pluggedInClass = $this->getPluggedInClass();
 74 |         }
 75 |         $dynamicPlugin  = $this->virtualPlugins->getDynamicVirtualPlugin($pluggedInClass, 'class');
 76 |         return $dynamicPlugin ? $dynamicPlugin->getPluginMethods() : [];
 77 |     }
 78 | 
 79 |     /**
 80 |      * Retrieve list of methods
 81 |      *
 82 |      * @param string $type
 83 |      * @return string[]
 84 |      */
 85 |     public function getMethodList($type)
 86 |     {
 87 |         $methods = [];
 88 |         if (is_a($type, "\Cmtickle\EventThing\Plugin\GenericPlugin", true)) {
 89 |             $allMethods = $this->getDynamicClassMethods();
 90 |         } elseif (class_exists($type)) {
 91 |             $allMethods = get_class_methods($type);
 92 |         } else {
 93 |             $dynamicPlugin = $this->virtualPlugins->getDynamicVirtualPlugin($type, 'virtual_type');
 94 |             $allMethods = $dynamicPlugin->getPluginMethods();
 95 |         }
 96 |         if ($allMethods) {
 97 |             foreach ($allMethods as $method) {
 98 |                 $prefix = substr($method, 0, 5);
 99 |                 if (isset($this->_typesByPrefixes[$prefix])) {
100 |                     $methodName = \lcfirst(substr($method, $this->prefixLengths[$this->_typesByPrefixes[$prefix]]));
101 |                     $methods[$methodName] = isset(
102 |                         $methods[$methodName]
103 |                     ) ? $methods[$methodName] | $this->_typesByPrefixes[$prefix] : $this->_typesByPrefixes[$prefix];
104 |                 }
105 |             }
106 |         }
107 |         return $methods;
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/gnu-gpl-v3.0.md:
--------------------------------------------------------------------------------
  1 | GNU General Public License
  2 | ==========================
  3 | 
  4 | _Version 3, 29 June 2007_
  5 | _Copyright © 2007 Free Software Foundation, Inc. &lt;<http://fsf.org/>&gt;_
  6 | 
  7 | Everyone is permitted to copy and distribute verbatim copies of this license
  8 | document, but changing it is not allowed.
  9 | 
 10 | ## Preamble
 11 | 
 12 | The GNU General Public License is a free, copyleft license for software and other
 13 | kinds of works.
 14 | 
 15 | The licenses for most software and other practical works are designed to take away
 16 | your freedom to share and change the works. By contrast, the GNU General Public
 17 | License is intended to guarantee your freedom to share and change all versions of a
 18 | program--to make sure it remains free software for all its users. We, the Free
 19 | Software Foundation, use the GNU General Public License for most of our software; it
 20 | applies also to any other work released this way by its authors. You can apply it to
 21 | your programs, too.
 22 | 
 23 | When we speak of free software, we are referring to freedom, not price. Our General
 24 | Public Licenses are designed to make sure that you have the freedom to distribute
 25 | copies of free software (and charge for them if you wish), that you receive source
 26 | code or can get it if you want it, that you can change the software or use pieces of
 27 | it in new free programs, and that you know you can do these things.
 28 | 
 29 | To protect your rights, we need to prevent others from denying you these rights or
 30 | asking you to surrender the rights. Therefore, you have certain responsibilities if
 31 | you distribute copies of the software, or if you modify it: responsibilities to
 32 | respect the freedom of others.
 33 | 
 34 | For example, if you distribute copies of such a program, whether gratis or for a fee,
 35 | you must pass on to the recipients the same freedoms that you received. You must make
 36 | sure that they, too, receive or can get the source code. And you must show them these
 37 | terms so they know their rights.
 38 | 
 39 | Developers that use the GNU GPL protect your rights with two steps: **(1)** assert
 40 | copyright on the software, and **(2)** offer you this License giving you legal permission
 41 | to copy, distribute and/or modify it.
 42 | 
 43 | For the developers' and authors' protection, the GPL clearly explains that there is
 44 | no warranty for this free software. For both users' and authors' sake, the GPL
 45 | requires that modified versions be marked as changed, so that their problems will not
 46 | be attributed erroneously to authors of previous versions.
 47 | 
 48 | Some devices are designed to deny users access to install or run modified versions of
 49 | the software inside them, although the manufacturer can do so. This is fundamentally
 50 | incompatible with the aim of protecting users' freedom to change the software. The
 51 | systematic pattern of such abuse occurs in the area of products for individuals to
 52 | use, which is precisely where it is most unacceptable. Therefore, we have designed
 53 | this version of the GPL to prohibit the practice for those products. If such problems
 54 | arise substantially in other domains, we stand ready to extend this provision to
 55 | those domains in future versions of the GPL, as needed to protect the freedom of
 56 | users.
 57 | 
 58 | Finally, every program is threatened constantly by software patents. States should
 59 | not allow patents to restrict development and use of software on general-purpose
 60 | computers, but in those that do, we wish to avoid the special danger that patents
 61 | applied to a free program could make it effectively proprietary. To prevent this, the
 62 | GPL assures that patents cannot be used to render the program non-free.
 63 | 
 64 | The precise terms and conditions for copying, distribution and modification follow.
 65 | 
 66 | ## TERMS AND CONDITIONS
 67 | 
 68 | ### 0. Definitions
 69 | 
 70 | “This License” refers to version 3 of the GNU General Public License.
 71 | 
 72 | “Copyright” also means copyright-like laws that apply to other kinds of
 73 | works, such as semiconductor masks.
 74 | 
 75 | “The Program” refers to any copyrightable work licensed under this
 76 | License. Each licensee is addressed as “you”. “Licensees” and
 77 | “recipients” may be individuals or organizations.
 78 | 
 79 | To “modify” a work means to copy from or adapt all or part of the work in
 80 | a fashion requiring copyright permission, other than the making of an exact copy. The
 81 | resulting work is called a “modified version” of the earlier work or a
 82 | work “based on” the earlier work.
 83 | 
 84 | A “covered work” means either the unmodified Program or a work based on
 85 | the Program.
 86 | 
 87 | To “propagate” a work means to do anything with it that, without
 88 | permission, would make you directly or secondarily liable for infringement under
 89 | applicable copyright law, except executing it on a computer or modifying a private
 90 | copy. Propagation includes copying, distribution (with or without modification),
 91 | making available to the public, and in some countries other activities as well.
 92 | 
 93 | To “convey” a work means any kind of propagation that enables other
 94 | parties to make or receive copies. Mere interaction with a user through a computer
 95 | network, with no transfer of a copy, is not conveying.
 96 | 
 97 | An interactive user interface displays “Appropriate Legal Notices” to the
 98 | extent that it includes a convenient and prominently visible feature that **(1)**
 99 | displays an appropriate copyright notice, and **(2)** tells the user that there is no
100 | warranty for the work (except to the extent that warranties are provided), that
101 | licensees may convey the work under this License, and how to view a copy of this
102 | License. If the interface presents a list of user commands or options, such as a
103 | menu, a prominent item in the list meets this criterion.
104 | 
105 | ### 1. Source Code
106 | 
107 | The “source code” for a work means the preferred form of the work for
108 | making modifications to it. “Object code” means any non-source form of a
109 | work.
110 | 
111 | A “Standard Interface” means an interface that either is an official
112 | standard defined by a recognized standards body, or, in the case of interfaces
113 | specified for a particular programming language, one that is widely used among
114 | developers working in that language.
115 | 
116 | The “System Libraries” of an executable work include anything, other than
117 | the work as a whole, that **(a)** is included in the normal form of packaging a Major
118 | Component, but which is not part of that Major Component, and **(b)** serves only to
119 | enable use of the work with that Major Component, or to implement a Standard
120 | Interface for which an implementation is available to the public in source code form.
121 | A “Major Component”, in this context, means a major essential component
122 | (kernel, window system, and so on) of the specific operating system (if any) on which
123 | the executable work runs, or a compiler used to produce the work, or an object code
124 | interpreter used to run it.
125 | 
126 | The “Corresponding Source” for a work in object code form means all the
127 | source code needed to generate, install, and (for an executable work) run the object
128 | code and to modify the work, including scripts to control those activities. However,
129 | it does not include the work's System Libraries, or general-purpose tools or
130 | generally available free programs which are used unmodified in performing those
131 | activities but which are not part of the work. For example, Corresponding Source
132 | includes interface definition files associated with source files for the work, and
133 | the source code for shared libraries and dynamically linked subprograms that the work
134 | is specifically designed to require, such as by intimate data communication or
135 | control flow between those subprograms and other parts of the work.
136 | 
137 | The Corresponding Source need not include anything that users can regenerate
138 | automatically from other parts of the Corresponding Source.
139 | 
140 | The Corresponding Source for a work in source code form is that same work.
141 | 
142 | ### 2. Basic Permissions
143 | 
144 | All rights granted under this License are granted for the term of copyright on the
145 | Program, and are irrevocable provided the stated conditions are met. This License
146 | explicitly affirms your unlimited permission to run the unmodified Program. The
147 | output from running a covered work is covered by this License only if the output,
148 | given its content, constitutes a covered work. This License acknowledges your rights
149 | of fair use or other equivalent, as provided by copyright law.
150 | 
151 | You may make, run and propagate covered works that you do not convey, without
152 | conditions so long as your license otherwise remains in force. You may convey covered
153 | works to others for the sole purpose of having them make modifications exclusively
154 | for you, or provide you with facilities for running those works, provided that you
155 | comply with the terms of this License in conveying all material for which you do not
156 | control copyright. Those thus making or running the covered works for you must do so
157 | exclusively on your behalf, under your direction and control, on terms that prohibit
158 | them from making any copies of your copyrighted material outside their relationship
159 | with you.
160 | 
161 | Conveying under any other circumstances is permitted solely under the conditions
162 | stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
163 | 
164 | ### 3. Protecting Users' Legal Rights From Anti-Circumvention Law
165 | 
166 | No covered work shall be deemed part of an effective technological measure under any
167 | applicable law fulfilling obligations under article 11 of the WIPO copyright treaty
168 | adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention
169 | of such measures.
170 | 
171 | When you convey a covered work, you waive any legal power to forbid circumvention of
172 | technological measures to the extent such circumvention is effected by exercising
173 | rights under this License with respect to the covered work, and you disclaim any
174 | intention to limit operation or modification of the work as a means of enforcing,
175 | against the work's users, your or third parties' legal rights to forbid circumvention
176 | of technological measures.
177 | 
178 | ### 4. Conveying Verbatim Copies
179 | 
180 | You may convey verbatim copies of the Program's source code as you receive it, in any
181 | medium, provided that you conspicuously and appropriately publish on each copy an
182 | appropriate copyright notice; keep intact all notices stating that this License and
183 | any non-permissive terms added in accord with section 7 apply to the code; keep
184 | intact all notices of the absence of any warranty; and give all recipients a copy of
185 | this License along with the Program.
186 | 
187 | You may charge any price or no price for each copy that you convey, and you may offer
188 | support or warranty protection for a fee.
189 | 
190 | ### 5. Conveying Modified Source Versions
191 | 
192 | You may convey a work based on the Program, or the modifications to produce it from
193 | the Program, in the form of source code under the terms of section 4, provided that
194 | you also meet all of these conditions:
195 | 
196 | * **a)** The work must carry prominent notices stating that you modified it, and giving a
197 | relevant date.
198 | * **b)** The work must carry prominent notices stating that it is released under this
199 | License and any conditions added under section 7. This requirement modifies the
200 | requirement in section 4 to “keep intact all notices”.
201 | * **c)** You must license the entire work, as a whole, under this License to anyone who
202 | comes into possession of a copy. This License will therefore apply, along with any
203 | applicable section 7 additional terms, to the whole of the work, and all its parts,
204 | regardless of how they are packaged. This License gives no permission to license the
205 | work in any other way, but it does not invalidate such permission if you have
206 | separately received it.
207 | * **d)** If the work has interactive user interfaces, each must display Appropriate Legal
208 | Notices; however, if the Program has interactive interfaces that do not display
209 | Appropriate Legal Notices, your work need not make them do so.
210 | 
211 | A compilation of a covered work with other separate and independent works, which are
212 | not by their nature extensions of the covered work, and which are not combined with
213 | it such as to form a larger program, in or on a volume of a storage or distribution
214 | medium, is called an “aggregate” if the compilation and its resulting
215 | copyright are not used to limit the access or legal rights of the compilation's users
216 | beyond what the individual works permit. Inclusion of a covered work in an aggregate
217 | does not cause this License to apply to the other parts of the aggregate.
218 | 
219 | ### 6. Conveying Non-Source Forms
220 | 
221 | You may convey a covered work in object code form under the terms of sections 4 and
222 | 5, provided that you also convey the machine-readable Corresponding Source under the
223 | terms of this License, in one of these ways:
224 | 
225 | * **a)** Convey the object code in, or embodied in, a physical product (including a
226 | physical distribution medium), accompanied by the Corresponding Source fixed on a
227 | durable physical medium customarily used for software interchange.
228 | * **b)** Convey the object code in, or embodied in, a physical product (including a
229 | physical distribution medium), accompanied by a written offer, valid for at least
230 | three years and valid for as long as you offer spare parts or customer support for
231 | that product model, to give anyone who possesses the object code either **(1)** a copy of
232 | the Corresponding Source for all the software in the product that is covered by this
233 | License, on a durable physical medium customarily used for software interchange, for
234 | a price no more than your reasonable cost of physically performing this conveying of
235 | source, or **(2)** access to copy the Corresponding Source from a network server at no
236 | charge.
237 | * **c)** Convey individual copies of the object code with a copy of the written offer to
238 | provide the Corresponding Source. This alternative is allowed only occasionally and
239 | noncommercially, and only if you received the object code with such an offer, in
240 | accord with subsection 6b.
241 | * **d)** Convey the object code by offering access from a designated place (gratis or for
242 | a charge), and offer equivalent access to the Corresponding Source in the same way
243 | through the same place at no further charge. You need not require recipients to copy
244 | the Corresponding Source along with the object code. If the place to copy the object
245 | code is a network server, the Corresponding Source may be on a different server
246 | (operated by you or a third party) that supports equivalent copying facilities,
247 | provided you maintain clear directions next to the object code saying where to find
248 | the Corresponding Source. Regardless of what server hosts the Corresponding Source,
249 | you remain obligated to ensure that it is available for as long as needed to satisfy
250 | these requirements.
251 | * **e)** Convey the object code using peer-to-peer transmission, provided you inform
252 | other peers where the object code and Corresponding Source of the work are being
253 | offered to the general public at no charge under subsection 6d.
254 | 
255 | A separable portion of the object code, whose source code is excluded from the
256 | Corresponding Source as a System Library, need not be included in conveying the
257 | object code work.
258 | 
259 | A “User Product” is either **(1)** a “consumer product”, which
260 | means any tangible personal property which is normally used for personal, family, or
261 | household purposes, or **(2)** anything designed or sold for incorporation into a
262 | dwelling. In determining whether a product is a consumer product, doubtful cases
263 | shall be resolved in favor of coverage. For a particular product received by a
264 | particular user, “normally used” refers to a typical or common use of
265 | that class of product, regardless of the status of the particular user or of the way
266 | in which the particular user actually uses, or expects or is expected to use, the
267 | product. A product is a consumer product regardless of whether the product has
268 | substantial commercial, industrial or non-consumer uses, unless such uses represent
269 | the only significant mode of use of the product.
270 | 
271 | “Installation Information” for a User Product means any methods,
272 | procedures, authorization keys, or other information required to install and execute
273 | modified versions of a covered work in that User Product from a modified version of
274 | its Corresponding Source. The information must suffice to ensure that the continued
275 | functioning of the modified object code is in no case prevented or interfered with
276 | solely because modification has been made.
277 | 
278 | If you convey an object code work under this section in, or with, or specifically for
279 | use in, a User Product, and the conveying occurs as part of a transaction in which
280 | the right of possession and use of the User Product is transferred to the recipient
281 | in perpetuity or for a fixed term (regardless of how the transaction is
282 | characterized), the Corresponding Source conveyed under this section must be
283 | accompanied by the Installation Information. But this requirement does not apply if
284 | neither you nor any third party retains the ability to install modified object code
285 | on the User Product (for example, the work has been installed in ROM).
286 | 
287 | The requirement to provide Installation Information does not include a requirement to
288 | continue to provide support service, warranty, or updates for a work that has been
289 | modified or installed by the recipient, or for the User Product in which it has been
290 | modified or installed. Access to a network may be denied when the modification itself
291 | materially and adversely affects the operation of the network or violates the rules
292 | and protocols for communication across the network.
293 | 
294 | Corresponding Source conveyed, and Installation Information provided, in accord with
295 | this section must be in a format that is publicly documented (and with an
296 | implementation available to the public in source code form), and must require no
297 | special password or key for unpacking, reading or copying.
298 | 
299 | ### 7. Additional Terms
300 | 
301 | “Additional permissions” are terms that supplement the terms of this
302 | License by making exceptions from one or more of its conditions. Additional
303 | permissions that are applicable to the entire Program shall be treated as though they
304 | were included in this License, to the extent that they are valid under applicable
305 | law. If additional permissions apply only to part of the Program, that part may be
306 | used separately under those permissions, but the entire Program remains governed by
307 | this License without regard to the additional permissions.
308 | 
309 | When you convey a copy of a covered work, you may at your option remove any
310 | additional permissions from that copy, or from any part of it. (Additional
311 | permissions may be written to require their own removal in certain cases when you
312 | modify the work.) You may place additional permissions on material, added by you to a
313 | covered work, for which you have or can give appropriate copyright permission.
314 | 
315 | Notwithstanding any other provision of this License, for material you add to a
316 | covered work, you may (if authorized by the copyright holders of that material)
317 | supplement the terms of this License with terms:
318 | 
319 | * **a)** Disclaiming warranty or limiting liability differently from the terms of
320 | sections 15 and 16 of this License; or
321 | * **b)** Requiring preservation of specified reasonable legal notices or author
322 | attributions in that material or in the Appropriate Legal Notices displayed by works
323 | containing it; or
324 | * **c)** Prohibiting misrepresentation of the origin of that material, or requiring that
325 | modified versions of such material be marked in reasonable ways as different from the
326 | original version; or
327 | * **d)** Limiting the use for publicity purposes of names of licensors or authors of the
328 | material; or
329 | * **e)** Declining to grant rights under trademark law for use of some trade names,
330 | trademarks, or service marks; or
331 | * **f)** Requiring indemnification of licensors and authors of that material by anyone
332 | who conveys the material (or modified versions of it) with contractual assumptions of
333 | liability to the recipient, for any liability that these contractual assumptions
334 | directly impose on those licensors and authors.
335 | 
336 | All other non-permissive additional terms are considered “further
337 | restrictions” within the meaning of section 10. If the Program as you received
338 | it, or any part of it, contains a notice stating that it is governed by this License
339 | along with a term that is a further restriction, you may remove that term. If a
340 | license document contains a further restriction but permits relicensing or conveying
341 | under this License, you may add to a covered work material governed by the terms of
342 | that license document, provided that the further restriction does not survive such
343 | relicensing or conveying.
344 | 
345 | If you add terms to a covered work in accord with this section, you must place, in
346 | the relevant source files, a statement of the additional terms that apply to those
347 | files, or a notice indicating where to find the applicable terms.
348 | 
349 | Additional terms, permissive or non-permissive, may be stated in the form of a
350 | separately written license, or stated as exceptions; the above requirements apply
351 | either way.
352 | 
353 | ### 8. Termination
354 | 
355 | You may not propagate or modify a covered work except as expressly provided under
356 | this License. Any attempt otherwise to propagate or modify it is void, and will
357 | automatically terminate your rights under this License (including any patent licenses
358 | granted under the third paragraph of section 11).
359 | 
360 | However, if you cease all violation of this License, then your license from a
361 | particular copyright holder is reinstated **(a)** provisionally, unless and until the
362 | copyright holder explicitly and finally terminates your license, and **(b)** permanently,
363 | if the copyright holder fails to notify you of the violation by some reasonable means
364 | prior to 60 days after the cessation.
365 | 
366 | Moreover, your license from a particular copyright holder is reinstated permanently
367 | if the copyright holder notifies you of the violation by some reasonable means, this
368 | is the first time you have received notice of violation of this License (for any
369 | work) from that copyright holder, and you cure the violation prior to 30 days after
370 | your receipt of the notice.
371 | 
372 | Termination of your rights under this section does not terminate the licenses of
373 | parties who have received copies or rights from you under this License. If your
374 | rights have been terminated and not permanently reinstated, you do not qualify to
375 | receive new licenses for the same material under section 10.
376 | 
377 | ### 9. Acceptance Not Required for Having Copies
378 | 
379 | You are not required to accept this License in order to receive or run a copy of the
380 | Program. Ancillary propagation of a covered work occurring solely as a consequence of
381 | using peer-to-peer transmission to receive a copy likewise does not require
382 | acceptance. However, nothing other than this License grants you permission to
383 | propagate or modify any covered work. These actions infringe copyright if you do not
384 | accept this License. Therefore, by modifying or propagating a covered work, you
385 | indicate your acceptance of this License to do so.
386 | 
387 | ### 10. Automatic Licensing of Downstream Recipients
388 | 
389 | Each time you convey a covered work, the recipient automatically receives a license
390 | from the original licensors, to run, modify and propagate that work, subject to this
391 | License. You are not responsible for enforcing compliance by third parties with this
392 | License.
393 | 
394 | An “entity transaction” is a transaction transferring control of an
395 | organization, or substantially all assets of one, or subdividing an organization, or
396 | merging organizations. If propagation of a covered work results from an entity
397 | transaction, each party to that transaction who receives a copy of the work also
398 | receives whatever licenses to the work the party's predecessor in interest had or
399 | could give under the previous paragraph, plus a right to possession of the
400 | Corresponding Source of the work from the predecessor in interest, if the predecessor
401 | has it or can get it with reasonable efforts.
402 | 
403 | You may not impose any further restrictions on the exercise of the rights granted or
404 | affirmed under this License. For example, you may not impose a license fee, royalty,
405 | or other charge for exercise of rights granted under this License, and you may not
406 | initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging
407 | that any patent claim is infringed by making, using, selling, offering for sale, or
408 | importing the Program or any portion of it.
409 | 
410 | ### 11. Patents
411 | 
412 | A “contributor” is a copyright holder who authorizes use under this
413 | License of the Program or a work on which the Program is based. The work thus
414 | licensed is called the contributor's “contributor version”.
415 | 
416 | A contributor's “essential patent claims” are all patent claims owned or
417 | controlled by the contributor, whether already acquired or hereafter acquired, that
418 | would be infringed by some manner, permitted by this License, of making, using, or
419 | selling its contributor version, but do not include claims that would be infringed
420 | only as a consequence of further modification of the contributor version. For
421 | purposes of this definition, “control” includes the right to grant patent
422 | sublicenses in a manner consistent with the requirements of this License.
423 | 
424 | Each contributor grants you a non-exclusive, worldwide, royalty-free patent license
425 | under the contributor's essential patent claims, to make, use, sell, offer for sale,
426 | import and otherwise run, modify and propagate the contents of its contributor
427 | version.
428 | 
429 | In the following three paragraphs, a “patent license” is any express
430 | agreement or commitment, however denominated, not to enforce a patent (such as an
431 | express permission to practice a patent or covenant not to sue for patent
432 | infringement). To “grant” such a patent license to a party means to make
433 | such an agreement or commitment not to enforce a patent against the party.
434 | 
435 | If you convey a covered work, knowingly relying on a patent license, and the
436 | Corresponding Source of the work is not available for anyone to copy, free of charge
437 | and under the terms of this License, through a publicly available network server or
438 | other readily accessible means, then you must either **(1)** cause the Corresponding
439 | Source to be so available, or **(2)** arrange to deprive yourself of the benefit of the
440 | patent license for this particular work, or **(3)** arrange, in a manner consistent with
441 | the requirements of this License, to extend the patent license to downstream
442 | recipients. “Knowingly relying” means you have actual knowledge that, but
443 | for the patent license, your conveying the covered work in a country, or your
444 | recipient's use of the covered work in a country, would infringe one or more
445 | identifiable patents in that country that you have reason to believe are valid.
446 | 
447 | If, pursuant to or in connection with a single transaction or arrangement, you
448 | convey, or propagate by procuring conveyance of, a covered work, and grant a patent
449 | license to some of the parties receiving the covered work authorizing them to use,
450 | propagate, modify or convey a specific copy of the covered work, then the patent
451 | license you grant is automatically extended to all recipients of the covered work and
452 | works based on it.
453 | 
454 | A patent license is “discriminatory” if it does not include within the
455 | scope of its coverage, prohibits the exercise of, or is conditioned on the
456 | non-exercise of one or more of the rights that are specifically granted under this
457 | License. You may not convey a covered work if you are a party to an arrangement with
458 | a third party that is in the business of distributing software, under which you make
459 | payment to the third party based on the extent of your activity of conveying the
460 | work, and under which the third party grants, to any of the parties who would receive
461 | the covered work from you, a discriminatory patent license **(a)** in connection with
462 | copies of the covered work conveyed by you (or copies made from those copies), or **(b)**
463 | primarily for and in connection with specific products or compilations that contain
464 | the covered work, unless you entered into that arrangement, or that patent license
465 | was granted, prior to 28 March 2007.
466 | 
467 | Nothing in this License shall be construed as excluding or limiting any implied
468 | license or other defenses to infringement that may otherwise be available to you
469 | under applicable patent law.
470 | 
471 | ### 12. No Surrender of Others' Freedom
472 | 
473 | If conditions are imposed on you (whether by court order, agreement or otherwise)
474 | that contradict the conditions of this License, they do not excuse you from the
475 | conditions of this License. If you cannot convey a covered work so as to satisfy
476 | simultaneously your obligations under this License and any other pertinent
477 | obligations, then as a consequence you may not convey it at all. For example, if you
478 | agree to terms that obligate you to collect a royalty for further conveying from
479 | those to whom you convey the Program, the only way you could satisfy both those terms
480 | and this License would be to refrain entirely from conveying the Program.
481 | 
482 | ### 13. Use with the GNU Affero General Public License
483 | 
484 | Notwithstanding any other provision of this License, you have permission to link or
485 | combine any covered work with a work licensed under version 3 of the GNU Affero
486 | General Public License into a single combined work, and to convey the resulting work.
487 | The terms of this License will continue to apply to the part which is the covered
488 | work, but the special requirements of the GNU Affero General Public License, section
489 | 13, concerning interaction through a network will apply to the combination as such.
490 | 
491 | ### 14. Revised Versions of this License
492 | 
493 | The Free Software Foundation may publish revised and/or new versions of the GNU
494 | General Public License from time to time. Such new versions will be similar in spirit
495 | to the present version, but may differ in detail to address new problems or concerns.
496 | 
497 | Each version is given a distinguishing version number. If the Program specifies that
498 | a certain numbered version of the GNU General Public License “or any later
499 | version” applies to it, you have the option of following the terms and
500 | conditions either of that numbered version or of any later version published by the
501 | Free Software Foundation. If the Program does not specify a version number of the GNU
502 | General Public License, you may choose any version ever published by the Free
503 | Software Foundation.
504 | 
505 | If the Program specifies that a proxy can decide which future versions of the GNU
506 | General Public License can be used, that proxy's public statement of acceptance of a
507 | version permanently authorizes you to choose that version for the Program.
508 | 
509 | Later license versions may give you additional or different permissions. However, no
510 | additional obligations are imposed on any author or copyright holder as a result of
511 | your choosing to follow a later version.
512 | 
513 | ### 15. Disclaimer of Warranty
514 | 
515 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
516 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
517 | PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER
518 | EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
519 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE
520 | QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
521 | DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
522 | 
523 | ### 16. Limitation of Liability
524 | 
525 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY
526 | COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS
527 | PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
528 | INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
529 | PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE
530 | OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
531 | WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
532 | POSSIBILITY OF SUCH DAMAGES.
533 | 
534 | ### 17. Interpretation of Sections 15 and 16
535 | 
536 | If the disclaimer of warranty and limitation of liability provided above cannot be
537 | given local legal effect according to their terms, reviewing courts shall apply local
538 | law that most closely approximates an absolute waiver of all civil liability in
539 | connection with the Program, unless a warranty or assumption of liability accompanies
540 | a copy of the Program in return for a fee.
541 | 
542 | _END OF TERMS AND CONDITIONS_
543 | 
544 | ## How to Apply These Terms to Your New Programs
545 | 
546 | If you develop a new program, and you want it to be of the greatest possible use to
547 | the public, the best way to achieve this is to make it free software which everyone
548 | can redistribute and change under these terms.
549 | 
550 | To do so, attach the following notices to the program. It is safest to attach them
551 | to the start of each source file to most effectively state the exclusion of warranty;
552 | and each file should have at least the “copyright” line and a pointer to
553 | where the full notice is found.
554 | 
555 |     <one line to give the program's name and a brief idea of what it does.>
556 |     Copyright (C) <year>  <name of author>
557 | 
558 |     This program is free software: you can redistribute it and/or modify
559 |     it under the terms of the GNU General Public License as published by
560 |     the Free Software Foundation, either version 3 of the License, or
561 |     (at your option) any later version.
562 | 
563 |     This program is distributed in the hope that it will be useful,
564 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
565 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
566 |     GNU General Public License for more details.
567 | 
568 |     You should have received a copy of the GNU General Public License
569 |     along with this program.  If not, see <http://www.gnu.org/licenses/>.
570 | 
571 | Also add information on how to contact you by electronic and paper mail.
572 | 
573 | If the program does terminal interaction, make it output a short notice like this
574 | when it starts in an interactive mode:
575 | 
576 |     <program>  Copyright (C) <year>  <name of author>
577 |     This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'.
578 |     This is free software, and you are welcome to redistribute it
579 |     under certain conditions; type 'show c' for details.
580 | 
581 | The hypothetical commands `show w` and `show c` should show the appropriate parts of
582 | the General Public License. Of course, your program's commands might be different;
583 | for a GUI interface, you would use an “about box”.
584 | 
585 | You should also get your employer (if you work as a programmer) or school, if any, to
586 | sign a “copyright disclaimer” for the program, if necessary. For more
587 | information on this, and how to apply and follow the GNU GPL, see
588 | &lt;<http://www.gnu.org/licenses/>&gt;.
589 | 
590 | The GNU General Public License does not permit incorporating your program into
591 | proprietary programs. If your program is a subroutine library, you may consider it
592 | more useful to permit linking proprietary applications with the library. If this is
593 | what you want to do, use the GNU Lesser General Public License instead of this
594 | License. But first, please read
595 | &lt;<http://www.gnu.org/philosophy/why-not-lgpl.html>&gt;.
596 | 


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