1: <?php
   2: 
   3: namespace Alpha\View;
   4: 
   5: use Alpha\Util\Logging\Logger;
   6: use Alpha\Util\Config\ConfigProvider;
   7: use Alpha\Model\ActiveRecord;
   8: use Alpha\Exception\IllegalArguementException;
   9: use Alpha\View\Renderer\RendererProviderFactory;
  10: use Alpha\View\Renderer\RendererProviderInterface;
  11: use ReflectionClass;
  12: 
  13: /**
  14:  * The master rendering view class for the Alpha Framework.
  15:  *
  16:  * @since 1.0
  17:  *
  18:  * @author John Collins <dev@alphaframework.org>
  19:  * @license http://www.opensource.org/licenses/bsd-license.php The BSD License
  20:  * @copyright Copyright (c) 2015, John Collins (founder of Alpha Framework).
  21:  * All rights reserved.
  22:  *
  23:  * <pre>
  24:  * Redistribution and use in source and binary forms, with or
  25:  * without modification, are permitted provided that the
  26:  * following conditions are met:
  27:  *
  28:  * * Redistributions of source code must retain the above
  29:  *   copyright notice, this list of conditions and the
  30:  *   following disclaimer.
  31:  * * Redistributions in binary form must reproduce the above
  32:  *   copyright notice, this list of conditions and the
  33:  *   following disclaimer in the documentation and/or other
  34:  *   materials provided with the distribution.
  35:  * * Neither the name of the Alpha Framework nor the names
  36:  *   of its contributors may be used to endorse or promote
  37:  *   products derived from this software without specific
  38:  *   prior written permission.
  39:  *
  40:  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  41:  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  42:  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  43:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  44:  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  45:  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  46:  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  47:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  48:  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  49:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  50:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  51:  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  52:  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  53:  * </pre>
  54:  */
  55: class View
  56: {
  57:     /**
  58:      * The business object that will be rendered.
  59:      *
  60:      * @var Alpha\Model\ActiveRecord
  61:      *
  62:      * @since 1.0
  63:      */
  64:     protected $BO;
  65: 
  66:     /**
  67:      * The rendering provider that will be used to render the active record.
  68:      *
  69:      * @var Alpha\View\Renderer\RendererProviderInterface
  70:      *
  71:      * @since 1.2
  72:      */
  73:     private static $provider;
  74: 
  75:     /**
  76:      * Trace logger.
  77:      *
  78:      * @var Logger
  79:      *
  80:      * @since 1.0
  81:      */
  82:     private static $logger = null;
  83: 
  84:     /**
  85:      * Constructor for the View.  As this is protected, use the View::getInstance method from a public scope.
  86:      *
  87:      * @param ActiveRecord $BO           The main business object that this view is going to render
  88:      * @param string       $acceptHeader Optionally pass the HTTP Accept header to select the correct renderer provider.
  89:      *
  90:      * @throws Alpha\Exception\IllegalArguementException
  91:      *
  92:      * @since 1.0
  93:      */
  94:     protected function __construct($BO, $acceptHeader = null)
  95:     {
  96:         self::$logger = new Logger('View');
  97:         self::$logger->debug('>>__construct(BO=['.var_export($BO, true).'], acceptHeader=['.$acceptHeader.'])');
  98: 
  99:         $config = ConfigProvider::getInstance();
 100: 
 101:         if ($BO instanceof ActiveRecord) {
 102:             $this->BO = $BO;
 103:         } else {
 104:             throw new IllegalArguementException('The BO provided ['.get_class($BO).'] is not defined anywhere!');
 105:         }
 106: 
 107:         self::setProvider($config->get('app.renderer.provider.name'), $acceptHeader);
 108:         self::$provider->setBO($this->BO);
 109: 
 110:         self::$logger->debug('<<__construct');
 111:     }
 112: 
 113:     /**
 114:      * Static method which returns a View object or a custom child view for the BO specified
 115:      * if one exists.
 116:      *
 117:      * @param ActiveRecord $BO           The main business object that this view is going to render
 118:      * @param bool         $returnParent Flag to enforce the return of this object instead of a child (defaults to false)
 119:      * @param string       $acceptHeader Optionally pass the HTTP Accept header to select the correct renderer provider.
 120:      *
 121:      * @return View Returns a View object, or a child view object if one exists for this BO
 122:      *
 123:      * @since 1.0
 124:      */
 125:     public static function getInstance($BO, $returnParent = false, $acceptHeader = null)
 126:     {
 127:         if (self::$logger == null) {
 128:             self::$logger = new Logger('View');
 129:         }
 130:         self::$logger->debug('>>getInstance(BO=['.var_export($BO, true).'], returnParent=['.$returnParent.'], acceptHeader=['.$acceptHeader.'])');
 131: 
 132:         $config = ConfigProvider::getInstance();
 133: 
 134:         $class = new ReflectionClass($BO);
 135:         $childView = $class->getShortname();
 136:         $childView = $childView.'View';
 137: 
 138:         // Check to see if a custom view exists for this BO, and if it does return that view instead
 139:         if (!$returnParent) {
 140:             $className = '\Alpha\View\\'.$childView;
 141: 
 142:             if (class_exists($className)) {
 143:                 self::$logger->debug('<<getInstance [new '.$className.'('.get_class($BO).')]');
 144: 
 145:                 $instance = new $className($BO, $acceptHeader);
 146: 
 147:                 return $instance;
 148:             }
 149: 
 150:             $className = '\View\\'.$childView;
 151: 
 152:             if (class_exists('\View\\'.$childView)) {
 153:                 self::$logger->debug('<<getInstance [new '.$className.'('.get_class($BO).')]');
 154: 
 155:                 $instance = new $className($BO, $acceptHeader);
 156: 
 157:                 return $instance;
 158:             }
 159: 
 160:             self::$logger->debug('<<getInstance [new View('.get_class($BO).', '.$acceptHeader.')]');
 161: 
 162:             return new self($BO, $acceptHeader);
 163:         } else {
 164:             self::$logger->debug('<<getInstance [new View('.get_class($BO).', '.$acceptHeader.')]');
 165: 
 166:             return new self($BO, $acceptHeader);
 167:         }
 168:     }
 169: 
 170:     /**
 171:      * Simple setter for the view business object.
 172:      *
 173:      * @param Alpha\Model\ActiveRecord $BO
 174:      *
 175:      * @throws Alpha\Exception\IllegalArguementException
 176:      *
 177:      * @since 1.0
 178:      */
 179:     public function setBO($BO)
 180:     {
 181:         self::$logger->debug('>>setBO(BO=['.var_export($BO, true).'])');
 182: 
 183:         if ($BO instanceof \Alpha\Model\ActiveRecord) {
 184:             $this->BO = $BO;
 185:         } else {
 186:             throw new IllegalArguementException('The BO provided ['.get_class($BO).'] is not defined anywhere!');
 187:         }
 188: 
 189:         self::$logger->debug('<<setBO');
 190:     }
 191: 
 192:     /**
 193:      * Gets the BO attached to this view (if any).
 194:      *
 195:      * @return Alpha\Model\ActiveRecord
 196:      *
 197:      * @since 1.0
 198:      */
 199:     public function getBO()
 200:     {
 201:         return $this->BO;
 202:     }
 203: 
 204:     /**
 205:      * Renders the default create view.
 206:      *
 207:      * @param array $fields Hash array of fields to pass to the template
 208:      *
 209:      * @return string
 210:      *
 211:      * @since 1.0
 212:      */
 213:     public function createView($fields = array())
 214:     {
 215:         self::$logger->debug('>>createView(fields=['.var_export($fields, true).'])');
 216: 
 217:         if (method_exists($this, 'before_createView_callback')) {
 218:             $this->before_createView_callback();
 219:         }
 220: 
 221:         $config = ConfigProvider::getInstance();
 222: 
 223:         $body = self::$provider->createView($fields);
 224: 
 225:         if (method_exists($this, 'after_createView_callback')) {
 226:             $this->after_createView_callback();
 227:         }
 228: 
 229:         self::$logger->debug('<<createView');
 230: 
 231:         return $body;
 232:     }
 233: 
 234:     /**
 235:      * Renders a form to enable object editing.
 236:      *
 237:      * @param array $fields Hash array of fields to pass to the template
 238:      *
 239:      * @return string
 240:      *
 241:      * @since 1.0
 242:      */
 243:     public function editView($fields = array())
 244:     {
 245:         self::$logger->debug('>>editView(fields=['.var_export($fields, true).'])');
 246: 
 247:         if (method_exists($this, 'before_editView_callback')) {
 248:             $this->before_editView_callback();
 249:         }
 250: 
 251:         $config = ConfigProvider::getInstance();
 252: 
 253:         $body = self::$provider->editView($fields);
 254: 
 255:         if (method_exists($this, 'after_editView_callback')) {
 256:             $this->after_editView_callback();
 257:         }
 258: 
 259:         self::$logger->debug('<<editView');
 260: 
 261:         return $body;
 262:     }
 263: 
 264:     /**
 265:      * Renders the list view.
 266:      *
 267:      * @param array $fields Hash array of fields to pass to the template
 268:      *
 269:      * @return string
 270:      *
 271:      * @since 1.0
 272:      */
 273:     public function listView($fields = array())
 274:     {
 275:         self::$logger->debug('>>listView(fields=['.var_export($fields, true).'])');
 276: 
 277:         if (method_exists($this, 'before_listView_callback')) {
 278:             $this->before_listView_callback();
 279:         }
 280: 
 281:         $config = ConfigProvider::getInstance();
 282: 
 283:         $body = self::$provider->listView($fields);
 284: 
 285:         if (method_exists($this, 'after_listView_callback')) {
 286:             $this->after_listView_callback();
 287:         }
 288: 
 289:         self::$logger->debug('<<listView');
 290: 
 291:         return $body;
 292:     }
 293: 
 294:     /**
 295:      * Renders a detailed view of the object (read-only).
 296:      *
 297:      * @param array $fields Hash array of fields to pass to the template
 298:      *
 299:      * @return string
 300:      *
 301:      * @since 1.0
 302:      */
 303:     public function detailedView($fields = array())
 304:     {
 305:         self::$logger->debug('>>detailedView(fields=['.var_export($fields, true).'])');
 306: 
 307:         if (method_exists($this, 'before_detailedView_callback')) {
 308:             $this->before_detailedView_callback();
 309:         }
 310: 
 311:         $config = ConfigProvider::getInstance();
 312: 
 313:         $body = self::$provider->detailedView($fields);
 314: 
 315:         if (method_exists($this, 'after_detailedView_callback')) {
 316:             $this->after_detailedView_callback();
 317:         }
 318: 
 319:         self::$logger->debug('<<detailedView');
 320: 
 321:         return $body;
 322:     }
 323: 
 324:     /**
 325:      * Renders the admin view for the business object screen.
 326:      *
 327:      * @param array $fields Hash array of fields to pass to the template
 328:      *
 329:      * @return string
 330:      *
 331:      * @since 1.0
 332:      */
 333:     public function adminView($fields = array())
 334:     {
 335:         self::$logger->debug('>>adminView(fields=['.var_export($fields, true).'])');
 336: 
 337:         if (method_exists($this, 'before_adminView_callback')) {
 338:             $this->before_adminView_callback();
 339:         }
 340: 
 341:         $config = ConfigProvider::getInstance();
 342: 
 343:         $body = self::$provider->adminView($fields);
 344: 
 345:         if (method_exists($this, 'after_adminView_callback')) {
 346:             $this->after_adminView_callback();
 347:         }
 348: 
 349:         self::$logger->debug('<<adminView');
 350: 
 351:         return $body;
 352:     }
 353: 
 354:     /**
 355:      * Method to render the page header content.
 356:      *
 357:      * @param Alpha\Controller\Controller $controller
 358:      *
 359:      * @return string
 360:      *
 361:      * @throws Alpha\Exception\IllegalArguementException
 362:      *
 363:      * @since 1.0
 364:      */
 365:     public static function displayPageHead($controller)
 366:     {
 367:         if (self::$logger == null) {
 368:             self::$logger = new Logger('View');
 369:         }
 370:         self::$logger->debug('>>displayPageHead(controller=['.var_export($controller, true).'])');
 371: 
 372:         if (method_exists($controller, 'before_displayPageHead_callback')) {
 373:             $controller->before_displayPageHead_callback();
 374:         }
 375: 
 376:         $config = ConfigProvider::getInstance();
 377: 
 378:         if (!self::$provider instanceof RendererProviderInterface) {
 379:             self::setProvider($config->get('app.renderer.provider.name'));
 380:         }
 381: 
 382:         $provider = self::$provider;
 383:         $header = $provider::displayPageHead($controller);
 384: 
 385:         if (method_exists($controller, 'after_displayPageHead_callback')) {
 386:             $header .= $controller->after_displayPageHead_callback();
 387:         }
 388: 
 389:         self::$logger->debug('<<displayPageHead ['.$header.']');
 390: 
 391:         return $header;
 392:     }
 393: 
 394:     /**
 395:      * Method to render the page footer content.
 396:      *
 397:      * @param Alpha\Aonctoller\Controller $controller
 398:      *
 399:      * @return string
 400:      *
 401:      * @since 1.0
 402:      */
 403:     public static function displayPageFoot($controller)
 404:     {
 405:         if (self::$logger == null) {
 406:             self::$logger = new Logger('View');
 407:         }
 408: 
 409:         self::$logger->debug('>>displayPageFoot(controller=['.get_class($controller).'])');
 410: 
 411:         $config = ConfigProvider::getInstance();
 412: 
 413:         $footer = '';
 414: 
 415:         if (method_exists($controller, 'before_displayPageFoot_callback')) {
 416:             $footer .= $controller->before_displayPageFoot_callback();
 417:         }
 418: 
 419:         if (!self::$provider instanceof RendererProviderInterface) {
 420:             self::setProvider($config->get('app.renderer.provider.name'));
 421:         }
 422: 
 423:         $provider = self::$provider;
 424:         $footer .= $provider::displayPageFoot($controller);
 425: 
 426:         if (method_exists($controller, 'after_displayPageFoot_callback')) {
 427:             $footer .= $controller->after_displayPageFoot_callback();
 428:         }
 429: 
 430:         self::$logger->debug('<<displayPageFoot ['.$footer.']');
 431: 
 432:         return $footer;
 433:     }
 434: 
 435:     /**
 436:      * Renders the content for an update (e.g. successful save) message.
 437:      *
 438:      * @param string $message
 439:      *
 440:      * @return string
 441:      *
 442:      * @since 1.0
 443:      */
 444:     public static function displayUpdateMessage($message)
 445:     {
 446:         if (self::$logger == null) {
 447:             self::$logger = new Logger('View');
 448:         }
 449:         self::$logger->debug('>>displayUpdateMessage(message=['.$message.'])');
 450: 
 451:         $config = ConfigProvider::getInstance();
 452: 
 453:         if (!self::$provider instanceof RendererProviderInterface) {
 454:             self::setProvider($config->get('app.renderer.provider.name'));
 455:         }
 456: 
 457:         $provider = self::$provider;
 458:         $message = $provider::displayUpdateMessage($message);
 459: 
 460:         self::$logger->debug('<<displayUpdateMessage ['.$message.']');
 461: 
 462:         return $message;
 463:     }
 464: 
 465:     /**
 466:      * Renders the content for an error (e.g. save failed) message.
 467:      *
 468:      * @param string $message
 469:      *
 470:      * @return string
 471:      *
 472:      * @since 1.0
 473:      */
 474:     public static function displayErrorMessage($message)
 475:     {
 476:         if (self::$logger == null) {
 477:             self::$logger = new Logger('View');
 478:         }
 479:         self::$logger->debug('>>displayErrorMessage(message=['.$message.'])');
 480: 
 481:         $config = ConfigProvider::getInstance();
 482: 
 483:         if (!self::$provider instanceof RendererProviderInterface) {
 484:             self::setProvider($config->get('app.renderer.provider.name'));
 485:         }
 486: 
 487:         $provider = self::$provider;
 488:         $message = $provider::displayErrorMessage($message);
 489: 
 490:         self::$logger->debug('<<displayErrorMessage ['.$message.']');
 491: 
 492:         return $message;
 493:     }
 494: 
 495:     /**
 496:      * Renders an error page with the supplied error code (typlically a HTTP code) and a message.
 497:      *
 498:      * @param string $code
 499:      * @param string $message
 500:      *
 501:      * @return string
 502:      *
 503:      * @since 1.0
 504:      */
 505:     public static function renderErrorPage($code, $message)
 506:     {
 507:         if (self::$logger == null) {
 508:             self::$logger = new Logger('View');
 509:         }
 510:         self::$logger->debug('>>renderErrorPage(code=['.$code.'],message=['.$message.'])');
 511: 
 512:         $config = ConfigProvider::getInstance();
 513: 
 514:         if (!self::$provider instanceof RendererProviderInterface) {
 515:             self::setProvider($config->get('app.renderer.provider.name'));
 516:         }
 517: 
 518:         $provider = self::$provider;
 519:         $message = $provider::renderErrorPage($code, $message);
 520: 
 521:         self::$logger->debug('<<renderErrorPage ['.$message.']');
 522: 
 523:         return $message;
 524:     }
 525: 
 526:     /**
 527:      * Method to render a hidden HTML form for posting the OID of an object to be deleted.
 528:      *
 529:      * @param string $URI The URI that the form will point to
 530:      *
 531:      * @return string
 532:      *
 533:      * @since 1.0
 534:      */
 535:     public static function renderDeleteForm($URI)
 536:     {
 537:         if (self::$logger == null) {
 538:             self::$logger = new Logger('View');
 539:         }
 540:         self::$logger->debug('>>renderDeleteForm()');
 541: 
 542:         $config = ConfigProvider::getInstance();
 543: 
 544:         if (!self::$provider instanceof RendererProviderInterface) {
 545:             self::setProvider($config->get('app.renderer.provider.name'));
 546:         }
 547: 
 548:         $provider = self::$provider;
 549:         $html = $provider::renderDeleteForm($URI);
 550: 
 551:         self::$logger->debug('<<renderDeleteForm ['.$html.']');
 552: 
 553:         return $html;
 554:     }
 555: 
 556:     /**
 557:      * Method to render a HTML form with two hidden, hashed (MD5) form fields to be used as
 558:      * a check to ensure that a post to the controller is being sent from the same server
 559:      * as hosting it.
 560:      *
 561:      * @return string
 562:      *
 563:      * @since 1.0
 564:      */
 565:     public static function renderSecurityFields()
 566:     {
 567:         if (self::$logger == null) {
 568:             self::$logger = new Logger('View');
 569:         }
 570:         self::$logger->debug('>>renderSecurityFields()');
 571: 
 572:         $config = ConfigProvider::getInstance();
 573: 
 574:         if (!self::$provider instanceof RendererProviderInterface) {
 575:             self::setProvider($config->get('app.renderer.provider.name'));
 576:         }
 577: 
 578:         $provider = self::$provider;
 579:         $html = $provider::renderSecurityFields();
 580: 
 581:         self::$logger->debug('<<renderSecurityFields ['.$html.']');
 582: 
 583:         return $html;
 584:     }
 585: 
 586:     /**
 587:      * Method to render the default Integer HTML.
 588:      *
 589:      * @param string $name      The field name
 590:      * @param string $label     The label to apply to the field
 591:      * @param string $mode      The field mode (create/edit/view)
 592:      * @param string $value     The field value (optional)
 593:      * @param bool   $tableTags Include table tags and label (optional)
 594:      *
 595:      * @return string
 596:      *
 597:      * @since 1.0
 598:      */
 599:     public function renderIntegerField($name, $label, $mode, $value = '', $tableTags = true)
 600:     {
 601:         self::$logger->debug('>>renderIntegerField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
 602: 
 603:         $config = ConfigProvider::getInstance();
 604: 
 605:         $html = self::$provider->renderIntegerField($name, $label, $mode, $value, $tableTags);
 606: 
 607:         self::$logger->debug('<<renderIntegerField ['.$html.']');
 608: 
 609:         return $html;
 610:     }
 611: 
 612:     /**
 613:      * Method to render the default Double HTML.
 614:      *
 615:      * @param string $name      The field name
 616:      * @param string $label     The label to apply to the field
 617:      * @param string $mode      The field mode (create/edit/view)
 618:      * @param string $value     The field value (optional)
 619:      * @param bool   $tableTags Include table tags and label (optional)
 620:      *
 621:      * @return string
 622:      *
 623:      * @since 1.0
 624:      */
 625:     public function renderDoubleField($name, $label, $mode, $value = '', $tableTags = true)
 626:     {
 627:         self::$logger->debug('>>renderDoubleField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
 628: 
 629:         $config = ConfigProvider::getInstance();
 630: 
 631:         $html = self::$provider->renderDoubleField($name, $label, $mode, $value, $tableTags);
 632: 
 633:         self::$logger->debug('<<renderDoubleField ['.$html.']');
 634: 
 635:         return $html;
 636:     }
 637: 
 638:     /**
 639:      * Method to render the default Boolean HTML.
 640:      *
 641:      * @param string $name      The field name
 642:      * @param string $label     The label to apply to the field
 643:      * @param string $mode      The field mode (create/edit/view)
 644:      * @param string $value     The field value (optional)
 645:      * @param bool   $tableTags Include table tags and label (optional)
 646:      *
 647:      * @return string
 648:      *
 649:      * @since 1.0
 650:      */
 651:     public function renderBooleanField($name, $label, $mode, $value = '', $tableTags = true)
 652:     {
 653:         self::$logger->debug('>>renderBooleanField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
 654: 
 655:         $config = ConfigProvider::getInstance();
 656: 
 657:         $html = self::$provider->renderBooleanField($name, $label, $mode, $value, $tableTags);
 658: 
 659:         self::$logger->debug('<<renderBooleanField ['.$html.']');
 660: 
 661:         return $html;
 662:     }
 663: 
 664:     /**
 665:      * Method to render the default Enum HTML.
 666:      *
 667:      * @param string $name      The field name
 668:      * @param string $label     The label to apply to the field
 669:      * @param string $mode      The field mode (create/edit/view)
 670:      * @param array  $options   The Enum options
 671:      * @param string $value     The field value (optional)
 672:      * @param bool   $tableTags Include table tags and label (optional)
 673:      *
 674:      * @return string
 675:      *
 676:      * @since 1.0
 677:      */
 678:     public function renderEnumField($name, $label, $mode, $options, $value = '', $tableTags = true)
 679:     {
 680:         self::$logger->debug('>>renderEnumField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
 681: 
 682:         $config = ConfigProvider::getInstance();
 683: 
 684:         $html = self::$provider->renderEnumField($name, $label, $mode, $options, $value, $tableTags);
 685: 
 686:         self::$logger->debug('<<renderEnumField ['.$html.']');
 687: 
 688:         return $html;
 689:     }
 690: 
 691:     /**
 692:      * Method to render the default DEnum HTML.
 693:      *
 694:      * @param string $name      The field name
 695:      * @param string $label     The label to apply to the field
 696:      * @param string $mode      The field mode (create/edit/view)
 697:      * @param array  $options   The DEnum options
 698:      * @param string $value     The field value (optional)
 699:      * @param bool   $tableTags Include table tags and label (optional)
 700:      *
 701:      * @return string
 702:      *
 703:      * @since 1.0
 704:      */
 705:     public function renderDEnumField($name, $label, $mode, $options, $value = '', $tableTags = true)
 706:     {
 707:         self::$logger->debug('>>renderDEnumField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
 708: 
 709:         $config = ConfigProvider::getInstance();
 710: 
 711:         $html = self::$provider->renderDEnumField($name, $label, $mode, $options, $value, $tableTags);
 712: 
 713:         self::$logger->debug('<<renderDEnumField ['.$html.']');
 714: 
 715:         return $html;
 716:     }
 717: 
 718:     /**
 719:      * Method to render the default field HTML when type is not known.
 720:      *
 721:      * @param string $name      The field name
 722:      * @param string $label     The label to apply to the field
 723:      * @param string $mode      The field mode (create/edit/view)
 724:      * @param string $value     The field value (optional)
 725:      * @param bool   $tableTags Include table tags and label (optional)
 726:      *
 727:      * @return string
 728:      *
 729:      * @since 1.0
 730:      */
 731:     public function renderDefaultField($name, $label, $mode, $value = '', $tableTags = true)
 732:     {
 733:         self::$logger->debug('>>renderDefaultField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
 734: 
 735:         $config = ConfigProvider::getInstance();
 736: 
 737:         $html = self::$provider->renderDefaultField($name, $label, $mode, $value, $tableTags);
 738: 
 739:         self::$logger->debug('<<renderDefaultField ['.$html.']');
 740: 
 741:         return $html;
 742:     }
 743: 
 744:     /**
 745:      * render the default Text HTML.
 746:      *
 747:      * @param string $name      The field name
 748:      * @param string $label     The label to apply to the field
 749:      * @param string $mode      The field mode (create/edit/view)
 750:      * @param string $value     The field value (optional)
 751:      * @param bool   $tableTags Include table tags and label (optional)
 752:      *
 753:      * @return string
 754:      *
 755:      * @since 1.0
 756:      */
 757:     public function renderTextField($name, $label, $mode, $value = '', $tableTags = true)
 758:     {
 759:         self::$logger->debug('>>renderTextField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
 760: 
 761:         $config = ConfigProvider::getInstance();
 762: 
 763:         $html = self::$provider->renderTextField($name, $label, $mode, $value, $tableTags);
 764: 
 765:         self::$logger->debug('<<renderTextField ['.$html.']');
 766: 
 767:         return $html;
 768:     }
 769: 
 770:     /**
 771:      * render the default Relation HTML.
 772:      *
 773:      * @param string $name      The field name
 774:      * @param string $label     The label to apply to the field
 775:      * @param string $mode      The field mode (create/edit/view)
 776:      * @param string $value     The field value (optional)
 777:      * @param bool   $tableTags Include table tags and label (optional)
 778:      * @param bool   $expanded  Render the related fields in expanded format or not (optional)
 779:      * @param bool   $buttons   Render buttons for expanding/contacting the related fields (optional)
 780:      *
 781:      * @return string
 782:      *
 783:      * @since 1.0
 784:      */
 785:     public function renderRelationField($name, $label, $mode, $value = '', $tableTags = true, $expanded = false, $buttons = true)
 786:     {
 787:         self::$logger->debug('>>renderRelationField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'], expanded=['.$expanded.'], buttons=['.$buttons.'])');
 788: 
 789:         $config = ConfigProvider::getInstance();
 790: 
 791:         $html = self::$provider->renderRelationField($name, $label, $mode, $value, $tableTags, $expanded, $buttons);
 792: 
 793:         self::$logger->debug('<<renderRelationField ['.$html.']');
 794: 
 795:         return $html;
 796:     }
 797: 
 798:     /**
 799:      * Renders all fields for the current BO in edit/create/view mode.
 800:      *
 801:      * @param string $mode           (view|edit|create)
 802:      * @param array  $filterFields   Optional list of field names to exclude from rendering
 803:      * @param array  $readOnlyFields Optional list of fields to render in a readonly fashion when rendering in create or edit mode
 804:      *
 805:      * @return string
 806:      *
 807:      * @since 1.0
 808:      */
 809:     public function renderAllFields($mode, $filterFields = array(), $readOnlyFields = array())
 810:     {
 811:         self::$logger->debug('>>renderAllFields(mode=['.$mode.'], filterFields=['.var_export($filterFields, true).'], readOnlyFields=['.var_export($readOnlyFields, true).'])');
 812: 
 813:         $config = ConfigProvider::getInstance();
 814: 
 815:         $html = self::$provider->renderAllFields($mode, $filterFields, $readOnlyFields);
 816: 
 817:         self::$logger->debug('<<renderAllFields ['.$html.']');
 818: 
 819:         return $html;
 820:     }
 821: 
 822:     /**
 823:      * Loads a template for the BO specified if one exists.  Lower level custom templates
 824:      * take precedence.
 825:      *
 826:      * @param Alpha\Model\ActiveRecord $BO
 827:      * @param string                   $mode
 828:      * @param array                    $fields
 829:      *
 830:      * @return string
 831:      *
 832:      * @since 1.0
 833:      *
 834:      * @throws Alpha\Exception\IllegalArguementException
 835:      */
 836:     public static function loadTemplate($BO, $mode, $fields = array())
 837:     {
 838:         self::$logger->debug('>>loadTemplate(BO=['.var_export($BO, true).'], mode=['.$mode.'], fields=['.var_export($fields, true).'])');
 839: 
 840:         $config = ConfigProvider::getInstance();
 841: 
 842:         // for each BO property, create a local variable holding its value
 843:         $reflection = new ReflectionClass(get_class($BO));
 844:         $properties = $reflection->getProperties();
 845: 
 846:         foreach ($properties as $propObj) {
 847:             $propName = $propObj->name;
 848: 
 849:             if ($propName != 'logger' && !$propObj->isPrivate()) {
 850:                 $prop = $BO->getPropObject($propName);
 851:                 if ($prop instanceof DEnum) {
 852:                     ${$propName} = $BO->getPropObject($propName)->getDisplayValue();
 853:                 } else {
 854:                     ${$propName} = $BO->get($propName);
 855:                 }
 856:             }
 857:         }
 858: 
 859:         // loop over the $fields array and create a local variable for each key value
 860:         foreach (array_keys($fields) as $fieldName) {
 861:             ${$fieldName} = $fields[$fieldName];
 862:         }
 863: 
 864:         $filename = $mode.'.phtml';
 865:         $class = new ReflectionClass($BO);
 866:         $className = $class->getShortname();
 867: 
 868:         $customPath = $config->get('app.root').'src/View/Html/Templates/'.$className.'/'.$filename;
 869:         $defaultPath1 = $config->get('app.root').'vendor/alphadevx/alpha/Alpha/View/Renderer/Html/Templates/'.$className.'/'.$filename;
 870:         $defaultPath2 = $config->get('app.root').'vendor/alphadevx/alpha/Alpha/View/Renderer/Html/Templates/'.$filename;
 871:         $defaultPath3 = $config->get('app.root').'Alpha/View/Renderer/Html/Templates/'.$className.'/'.$filename;
 872:         $defaultPath4 = $config->get('app.root').'Alpha/View/Renderer/Html/Templates/'.$filename;
 873: 
 874:         // Check to see if a custom template exists for this BO, and if it does load that
 875:         if (file_exists($customPath)) {
 876:             self::$logger->debug('Loading template ['.$customPath.']');
 877:             ob_start();
 878:             require $customPath;
 879:             $html = ob_get_clean();
 880: 
 881:             return $html;
 882:         } elseif (file_exists($defaultPath1)) {
 883:             self::$logger->debug('Loading template ['.$defaultPath1.']');
 884:             ob_start();
 885:             require $defaultPath1;
 886:             $html = ob_get_clean();
 887: 
 888:             return $html;
 889:         } elseif (file_exists($defaultPath2)) {
 890:             self::$logger->debug('Loading template ['.$defaultPath2.']');
 891:             ob_start();
 892:             require $defaultPath2;
 893:             $html = ob_get_clean();
 894: 
 895:             return $html;
 896:         } elseif (file_exists($defaultPath3)) {
 897:             self::$logger->debug('Loading template ['.$defaultPath3.']');
 898:             ob_start();
 899:             require $defaultPath3;
 900:             $html = ob_get_clean();
 901: 
 902:             return $html;
 903:         } elseif (file_exists($defaultPath4)) {
 904:             self::$logger->debug('Loading template ['.$defaultPath4.']');
 905:             ob_start();
 906:             require $defaultPath4;
 907:             $html = ob_get_clean();
 908: 
 909:             return $html;
 910:         } else {
 911:             throw new IllegalArguementException('No ['.$mode.'] HTML template found for class ['.$className.']');
 912:         }
 913: 
 914:         self::$logger->debug('<<loadTemplate');
 915:     }
 916: 
 917:     /**
 918:      * Loads a template fragment from the Renderer/[type]/Fragments/[filename.ext] location.
 919:      *
 920:      * @param string $type     Currently only html supported, later json and xml.
 921:      * @param string $fileName The name of the fragment file
 922:      * @param array  $fields   A hash array of field values to pass to the template fragment.
 923:      *
 924:      * @return string
 925:      *
 926:      * @since 1.2
 927:      *
 928:      * @throws Alpha\Exception\IllegalArguementException
 929:      */
 930:     public static function loadTemplateFragment($type, $fileName, $fields = array())
 931:     {
 932:         if (self::$logger == null) {
 933:             self::$logger = new Logger('View');
 934:         }
 935:         self::$logger->debug('>>loadTemplateFragment(type=['.$type.'], fileName=['.$fileName.'], fields=['.var_export($fields, true).'])');
 936: 
 937:         $config = ConfigProvider::getInstance();
 938: 
 939:         // loop over the $fields array and create a local variable for each key value
 940:         foreach (array_keys($fields) as $fieldName) {
 941:             ${$fieldName} = $fields[$fieldName];
 942:         }
 943: 
 944:         $customPath = $config->get('app.root').'src/View/'.ucfirst($type).'/Fragments/'.$fileName;
 945:         $defaultPath1 = $config->get('app.root').'vendor/alphadevx/alpha/Alpha/View/Renderer/'.ucfirst($type).'/Fragments/'.$fileName;
 946:         $defaultPath2 = $config->get('app.root').'Alpha/View/Renderer/'.ucfirst($type).'/Fragments/'.$fileName;
 947: 
 948:         // Check to see if a custom template exists for this BO, and if it does load that
 949:         if (file_exists($customPath)) {
 950:             self::$logger->debug('Loading template ['.$customPath.']');
 951:             ob_start();
 952:             require $customPath;
 953:             $html = ob_get_clean();
 954: 
 955:             return $html;
 956:         } elseif (file_exists($defaultPath1)) {
 957:             self::$logger->debug('Loading template ['.$defaultPath1.']');
 958:             ob_start();
 959:             require $defaultPath1;
 960:             $html = ob_get_clean();
 961: 
 962:             return $html;
 963:         } elseif (file_exists($defaultPath2)) {
 964:             self::$logger->debug('Loading template ['.$defaultPath2.']');
 965:             ob_start();
 966:             require $defaultPath2;
 967:             $html = ob_get_clean();
 968: 
 969:             return $html;
 970:         } else {
 971:             throw new IllegalArguementException('Template fragment not found in ['.$customPath.'] or ['.$defaultPath1.'] or ['.$defaultPath2.']!');
 972:         }
 973: 
 974:         self::$logger->debug('<<loadTemplateFragment');
 975:     }
 976: 
 977:     /**
 978:      * Enables you to set an explicit type of RendererProviderInterface implementation to use for rendering the records
 979:      * attached to this view.
 980:      *
 981:      * @param string $ProviderClassName The name of the RendererProviderInterface implementation to use in this view object
 982:      * @param string $acceptHeader      Optional pass the HTTP Accept header to select the correct renderer provider.
 983:      *
 984:      * @since 1.2
 985:      *
 986:      * @throws Alpha\Exception\IllegalArguementException
 987:      */
 988:     public static function setProvider($ProviderClassName, $acceptHeader = null)
 989:     {
 990:         if ($ProviderClassName == 'auto') {
 991:             $ProviderClassName = 'Alpha\View\Renderer\Html\RendererProviderHTML';
 992: 
 993:             if ($acceptHeader == 'application/json') {
 994:                 $ProviderClassName = 'Alpha\View\Renderer\Json\RendererProviderJSON';
 995:             }
 996: 
 997:             self::$provider = RendererProviderFactory::getInstance($ProviderClassName);
 998:         } else {
 999:             if (class_exists($ProviderClassName)) {
1000:                 $provider = new $ProviderClassName();
1001: 
1002:                 if ($provider instanceof RendererProviderInterface) {
1003:                     self::$provider = RendererProviderFactory::getInstance($ProviderClassName);
1004:                 } else {
1005:                     throw new IllegalArguementException('The provider class ['.$ProviderClassName.'] does not implement the RendererProviderInterface interface!');
1006:                 }
1007:             } else {
1008:                 throw new IllegalArguementException('The provider class ['.$ProviderClassName.'] does not exist!');
1009:             }
1010:         }
1011:     }
1012: 
1013:     /**
1014:      * Get the current view renderer provider.
1015:      *
1016:      * @return Alpha\View\Renderer\RendererProviderInterface
1017:      *
1018:      * @since 2.0
1019:      */
1020:     public static function getProvider()
1021:     {
1022:         if (self::$provider instanceof RendererProviderInterface) {
1023:             return self::$provider;
1024:         } else {
1025:             self::$provider = RendererProviderFactory::getInstance($config->get('app.renderer.provider.name'));
1026: 
1027:             return self::$provider;
1028:         }
1029:     }
1030: }
1031: