]> git.mxchange.org Git - core.git/blob - framework/main/classes/template/mail/class_MailTemplateEngine.php
Some updates:
[core.git] / framework / main / classes / template / mail / class_MailTemplateEngine.php
1 <?php
2 // Own namespace
3 namespace Org\Mxchange\CoreFramework\Template\Engine;
4
5 // Import framework stuff
6 use Org\Mxchange\CoreFramework\Filesystem\InvalidDirectoryException;
7 use Org\Mxchange\CoreFramework\Mailer\DeliverableMail;
8 use Org\Mxchange\CoreFramework\Parser\Xml\XmlParser;
9 use Org\Mxchange\CoreFramework\Registry\Registry;
10 use Org\Mxchange\CoreFramework\Response\Responseable;
11 use Org\Mxchange\CoreFramework\Template\CompileableTemplate;
12 use Org\Mxchange\CoreFramework\Template\Engine\BaseTemplateEngine;
13
14 // Import SPL stuff
15 use \UnexpectedValueException;
16
17 /**
18  * The own template engine for loading caching and sending out images
19  *
20  * @author              Roland Haeder <webmaster@shipsimu.org>
21  * @version             0.0.0
22 <<<<<<< HEAD:framework/main/classes/template/mail/class_MailTemplateEngine.php
23  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2017 Core Developer Team
24 =======
25  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2016 Core Developer Team
26 >>>>>>> Some updates::inc/main/classes/template/mail/class_MailTemplateEngine.php
27  * @license             GNU GPL 3.0 or any newer version
28  * @link                http://www.shipsimu.org
29  * @todo                This template engine does not make use of setTemplateType()
30  *
31  * This program is free software: you can redistribute it and/or modify
32  * it under the terms of the GNU General Public License as published by
33  * the Free Software Foundation, either version 3 of the License, or
34  * (at your option) any later version.
35  *
36  * This program is distributed in the hope that it will be useful,
37  * but WITHOUT ANY WARRANTY; without even the implied warranty of
38  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
39  * GNU General Public License for more details.
40  *
41  * You should have received a copy of the GNU General Public License
42  * along with this program. If not, see <http://www.gnu.org/licenses/>.
43  */
44 class MailTemplateEngine extends BaseTemplateEngine implements CompileableTemplate {
45         /**
46          * Main nodes in the XML tree
47          */
48         private $mainNodes = array(
49                 'mail-data'
50         );
51
52         /**
53          * Sub nodes in the XML tree
54          */
55         private $subNodes = array(
56                 'subject-line',
57                 'sender-address',
58                 'recipient-address',
59                 'message'
60         );
61
62         /**
63          * Mailer instance
64          */
65         private $mailerInstance = NULL;
66
67         /**
68          * Current main node
69          */
70         private $currMainNode = '';
71
72         /**
73          * Protected constructor
74          *
75          * @return      void
76          */
77         protected function __construct () {
78                 // Call parent constructor
79                 parent::__construct(__CLASS__);
80         }
81
82         /**
83          * Creates an instance of the class TemplateEngine and prepares it for usage
84          *
85          * @return      $templateInstance               An instance of TemplateEngine
86          * @throws      UnexpectedValueException                If the provided $templateBasePath is empty or no string
87          * @throws      InvalidDirectoryException       If $templateBasePath is no
88          *                                                                                      directory or not found
89          * @throws      BasePathReadProtectedException  If $templateBasePath is
90          *                                                                                      read-protected
91          */
92         public static final function createMailTemplateEngine () {
93                 // Get a new instance
94                 $templateInstance = new MailTemplateEngine();
95
96                 // Get the application instance from registry
97                 $applicationInstance = Registry::getRegistry()->getInstance('app');
98
99                 // Determine base path
100                 $templateBasePath = $templateInstance->getConfigInstance()->getConfigEntry('application_base_path') . $applicationInstance->getAppShortName(). '/';
101
102                 // Is the base path valid?
103                 if (empty($templateBasePath)) {
104                         // Base path is empty
105                         throw new UnexpectedValueException(sprintf('[%s:%d] Variable templateBasePath is empty.', $templateInstance->__toString(), __LINE__), self::EXCEPTION_UNEXPECTED_EMPTY_STRING);
106                 } elseif (!is_string($templateBasePath)) {
107                         // Is not a string
108                         throw new UnexpectedValueException(sprintf('[%s:%d] %s is not a string with a base path.', $templateInstance->__toString(), __LINE__, $templateBasePath), self::EXCEPTION_INVALID_STRING);
109                 } elseif (!is_dir($templateBasePath)) {
110                         // Is not a path
111                         throw new InvalidDirectoryException(array($templateInstance, $templateBasePath), self::EXCEPTION_INVALID_PATH_NAME);
112                 } elseif (!is_readable($templateBasePath)) {
113                         // Is not readable
114                         throw new BasePathReadProtectedException(array($templateInstance, $templateBasePath), self::EXCEPTION_READ_PROTECED_PATH);
115                 }
116
117                 // Set the base path
118                 $templateInstance->setTemplateBasePath($templateBasePath);
119
120                 // Set template extensions
121                 $templateInstance->setRawTemplateExtension($templateInstance->getConfigInstance()->getConfigEntry('raw_template_extension'));
122                 $templateInstance->setCodeTemplateExtension($templateInstance->getConfigInstance()->getConfigEntry('code_template_extension'));
123
124                 // Absolute output path for compiled templates
125                 $templateInstance->setCompileOutputPath(sprintf('%s%s/',
126                         $templateBasePath,
127                         $templateInstance->getConfigInstance()->getConfigEntry('compile_output_path')
128                 ));
129
130                 // Return the prepared instance
131                 return $templateInstance;
132         }
133
134         /**
135          * Getter for current main node
136          *
137          * @return      $currMainNode   Current main node
138          */
139         public final function getCurrMainNode () {
140                 return $this->currMainNode;
141         }
142
143         /**
144          * Getter for main node array
145          *
146          * @return      $mainNodes      Array with valid main node names
147          */
148         public final function getMainNodes () {
149                 return $this->mainNodes;
150         }
151
152         /**
153          * Getter for sub node array
154          *
155          * @return      $subNodes       Array with valid sub node names
156          */
157         public final function getSubNodes () {
158                 return $this->subNodes;
159         }
160
161         /**
162          * Handles the start element of an XML resource
163          *
164          * @param       $resource               XML parser resource (currently ignored)
165          * @param       $element                The element we shall handle
166          * @param       $attributes             All attributes
167          * @return      void
168          * @throws      InvalidXmlNodeException         If an unknown/invalid XML node name was found
169          */
170         public function startElement ($resource, $element, array $attributes) {
171                 // Initial method name which will never be called...
172                 $methodName = 'initEmail';
173
174                 // Make the element name lower-case
175                 $element = strtolower($element);
176
177                 // Is the element a main node?
178                 //* DEBUG: */ echo "START: &gt;".$element."&lt;<br />\n";
179                 if (in_array($element, $this->getMainNodes())) {
180                         // Okay, main node found!
181                         $methodName = 'setEmail' . self::convertToClassName($element);
182                 } elseif (in_array($element, $this->getSubNodes())) {
183                         // Sub node found
184                         $methodName = 'setEmailProperty' . self::convertToClassName($element);
185                 } elseif ($element != 'text-mail') {
186                         // Invalid node name found
187                         throw new InvalidXmlNodeException(array($this, $element, $attributes), XmlParser::EXCEPTION_XML_NODE_UNKNOWN);
188                 }
189
190                 // Call method
191                 //* DEBUG: */ echo "call: ".$methodName."<br />\n";
192                 call_user_func_array(array($this, $methodName), $attributes);
193         }
194
195         /**
196          * Ends the main or sub node by sending out the gathered data
197          *
198          * @param       $resource       An XML resource pointer (currently ignored)
199          * @param       $nodeName       Name of the node we want to finish
200          * @return      void
201          * @throws      XmlNodeMismatchException        If current main node mismatches the closing one
202          */
203         public function finishElement ($resource, $nodeName) {
204                 // Make all lower-case
205                 $nodeName = strtolower($nodeName);
206
207                 // Does this match with current main node?
208                 //* DEBUG: */ echo "END: &gt;".$nodeName."&lt;<br />\n";
209                 if (($nodeName != $this->getCurrMainNode()) && (in_array($nodeName, $this->getMainNodes()))) {
210                         // Did not match!
211                         throw new XmlNodeMismatchException (array($this, $nodeName, $this->getCurrMainNode()), XmlParser::EXCEPTION_XML_NODE_MISMATCH);
212                 } elseif (in_array($nodeName, $this->getSubNodes())) {
213                         // Silently ignore sub nodes
214                         return;
215                 }
216
217                 // Construct method name
218                 $methodName = 'finish' . self::convertToClassName($nodeName);
219
220                 // Call the corresponding method
221                 call_user_func_array(array($this, $methodName), array());
222         }
223
224         /**
225          * Adds the message text to the template engine
226          *
227          * @param       $resource               XML parser resource (currently ignored)
228          * @param       $characters             Characters to handle
229          * @return      void
230          */
231         public function characterHandler ($resource, $characters) {
232                 // Trim all spaces away
233                 $characters = trim($characters);
234
235                 // Is this string empty?
236                 if (empty($characters)) {
237                         // Then skip it silently
238                         return;
239                 } // END - if
240
241                 // Add the message now
242                 $this->assignVariable('message', $characters);
243         }
244
245         /**
246          * Intializes the mail
247          *
248          * @return      void
249          * @todo        Add cache creation here
250          */
251         private function initEmail () {
252                 // Unfinished work!
253         }
254
255         /**
256          * Setter for mail data node
257          *
258          * @return      void
259          * @todo        Should we call back the mailer class here?
260          */
261         private function setEmailMailData () {
262                 // Set current main node
263                 $this->currMainNode = 'mail-data';
264         }
265
266         /**
267          * Setter for sender address property
268          *
269          * @param       $senderAddress  Sender address to set in email
270          * @return      void
271          */
272         private function setEmailPropertySenderAddress ($senderAddress) {
273                 // Set the template variable
274                 $this->assignVariable('sender', $senderAddress);
275         }
276
277         /**
278          * Setter for recipient address property
279          *
280          * @param       $recipientAddress       Recipient address to set in email
281          * @return      void
282          */
283         private function setEmailPropertyRecipientAddress ($recipientAddress) {
284                 // Set the template variable
285                 $this->assignVariable('recipient', $recipientAddress);
286         }
287
288         /**
289          * Setter for subject line property
290          *
291          * @return      void
292          */
293         private function setEmailPropertySubjectLine () {
294                 // Empty for now
295         }
296
297         /**
298          * Method stub to avoid output
299          *
300          * @return      void
301          */
302         private function setEmailPropertyMessage () {
303                 // Empty for now
304         }
305
306         /**
307          * Gets the template variable "message", stores it back as raw template data
308          * and compiles all variables so the mail message got prepared for output
309          *
310          * @return      void
311          */
312         private function finishMailData () {
313                 // Get the message and set it as new raw template data back
314                 $message = $this->readVariable('message');
315                 $this->setRawTemplateData($message);
316
317                 // Get some variables to compile
318                 //$sender = $this->compileRawCode($this->readVariable('sender'));
319                 //$this->assignVariable('sender', $sender);
320
321                 // Then compile all variables
322                 $this->compileVariables();
323         }
324
325         /**
326          * Invokes the final mail process
327          *
328          * @return      void
329          */
330         private function finishTextMail () {
331                 $this->getMailerInstance()->invokeMailDelivery();
332         }
333
334         /**
335          * Setter for mailer instance
336          *
337          * @param       $mailerInstance         A mailer instance
338          * @return      void
339          */
340         public final function setMailerInstance (DeliverableMail $mailerInstance) {
341                 $this->mailerInstance = $mailerInstance;
342         }
343
344         /**
345          * Getter for mailer instance
346          *
347          * @return      $mailerInstance         A mailer instance
348          */
349         protected final function getMailerInstance () {
350                 return $this->mailerInstance;
351         }
352
353         /**
354          * Outputs the mail to the world. This should only the mailer debug class do!
355          *
356          * @param       $responseInstance       An instance of a Responseable class
357          * @return      void
358          */
359         public function transferToResponse (Responseable $responseInstance) {
360                 $responseInstance->writeToBody($this->getCompiledData());
361         }
362
363 }