      1: <?php
      2:
      3: /**
      4:  *
      5:  * The master rendering view class for the Alpha Framework.
      6:  *
      7:  * @package alpha::view
      8:  * @since 1.0
      9:  * @author John Collins <dev@alphaframework.org>
     10:  * @version $Id: AlphaView.inc 1563 2012-08-04 14:36:54Z alphadevx $
     11:  * @license http://www.opensource.org/licenses/bsd-license.php The BSD License
     12:  * @copyright Copyright (c) 2012, John Collins (founder of Alpha Framework).
     13:  * All rights reserved.
     14:  *
     15:  * <pre>
     16:  * Redistribution and use in source and binary forms, with or
     17:  * without modification, are permitted provided that the
     18:  * following conditions are met:
     19:  *
     20:  * * Redistributions of source code must retain the above
     21:  *   copyright notice, this list of conditions and the
     22:  *   following disclaimer.
     23:  * * Redistributions in binary form must reproduce the above
     24:  *   copyright notice, this list of conditions and the
     25:  *   following disclaimer in the documentation and/or other
     26:  *   materials provided with the distribution.
     27:  * * Neither the name of the Alpha Framework nor the names
     28:  *   of its contributors may be used to endorse or promote
     29:  *   products derived from this software without specific
     30:  *   prior written permission.
     31:  *
     32:  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
     33:  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
     34:  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     35:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     36:  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
     37:  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     38:  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     39:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     40:  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     41:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     42:  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     43:  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     44:  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     45:  * </pre>
     46:  *
     47:  */
     48: class AlphaView {
     49:     /**
     50:      * The business object that will be rendered
     51:      *
     52:      * @var AlphaDAO
     53:      * @since 1.0
     54:      */
     55:     protected $BO;
     56:
     57:         /**
     58:          * The rendering provider that will be used to render the business object
     59:          *
     60:          * @var AlphaRendererProviderInterface
     61:          * @since 1.2
     62:          */
     63:     protected $provider;
     64:
     65:     /**
     66:      * Trace logger
     67:      *
     68:      * @var Logger
     69:      * @since 1.0
     70:      */
     71:     private static $logger = null;
     72:
     73:     /**
     74:      * Constructor for the AlphaView.  As this is protected, use the AlphaView::getInstance method from a public scope.
     75:      *
     76:      * @param AlphaDAO $BO
     77:      * @throws IllegalArguementException
     78:      * @since 1.0
     79:      */
     80:     protected function __construct($BO) {
     81:         self::$logger = new Logger('AlphaView');
     82:         self::$logger->debug('>>__construct(BO=['.var_export($BO, true).'])');
     83:
     84:         global $config;
     85:
     86:         if(AlphaDAO::checkClassDefExists(get_class($BO)))
     87:             $this->BO = $BO;
     88:         else
     89:             throw new IllegalArguementException('The BO provided ['.get_class($BO).'] is not defined anywhere!');
     90:
     91:         $this->provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), $this->BO);
     92:
     93:         self::$logger->debug('<<__construct');
     94:     }
     95:
     96:     /**
     97:      * Static method which returns a AlphaView object or a custom child view for the BO specified
     98:      * if one exists
     99:      *
    100:      * @param AlphaDAO $BO The main business object that this view is going to render
    101:      * @param boolean $returnParent Flag to enforce the return of this object instead of a child (defaults to false)
    102:      * @return AlphaView Returns a AlphaView object, or a child view object from the /view directory if one exists for this BO
    103:      * @since 1.0
    104:      */
    105:     public static function getInstance($BO, $returnParent=false) {
    106:         if(self::$logger == null)
    107:             self::$logger = new Logger('AlphaView');
    108:         self::$logger->debug('>>getInstance(BO=['.var_export($BO, true).'], returnParent=['.$returnParent.'])');
    109:
    110:         global $config;
    111:
    112:         $filename = get_class($BO);
    113:         // remove the Object part
    114:         $filename = str_replace('Object', '', $filename);
    115:         // replace _ with space, then uppercase words
    116:         $filename = str_replace('_', ' ', $filename);
    117:         $filename = ucwords($filename).'View';
    118:         // finally, remove spaces
    119:         $filename = str_replace(' ', '', $filename);
    120:
    121:         // Check to see if a custom view exists for this BO, and if it does return that view instead
    122:         if (!$returnParent) {
    123:             if (file_exists($config->get('app.root').'view/'.$filename.'.inc')) {
    124:                 require_once $config->get('app.root').'view/'.$filename.'.inc';
    125:
    126:                 self::$logger->debug('<<getInstance [new '.$filename.'('.get_class($BO).')]');
    127:                 return new $filename($BO);
    128:             }elseif (file_exists($config->get('app.root').'alpha/view/'.$filename.'.inc')) {
    129:                 require_once $config->get('app.root').'alpha/view/'.$filename.'.inc';
    130:
    131:                 self::$logger->debug('<<getInstance [new '.$filename.'('.get_class($BO).')]');
    132:                 return new $filename($BO);
    133:             }else{
    134:                 self::$logger->debug('<<getInstance [new AlphaView('.get_class($BO).', true)]');
    135:                 return new AlphaView($BO, true);
    136:             }
    137:         }else{
    138:             self::$logger->debug('<<getInstance [new AlphaView('.get_class($BO).', true)]');
    139:             return new AlphaView($BO, true);
    140:         }
    141:     }
    142:
    143:     /**
    144:      * Simple setter for the view business object
    145:      *
    146:      * @param AlphaDAO $BO
    147:      * @throws IllegalArguementException
    148:      * @since 1.0
    149:      */
    150:     public function setBO($BO) {
    151:         self::$logger->debug('>>setBO(BO=['.var_export($BO, true).'])');
    152:
    153:         if(AlphaDAO::checkClassDefExists(get_class($BO)))
    154:             $this->BO = $BO;
    155:         else
    156:             throw new IllegalArguementException('The BO provided ['.get_class($BO).'] is not defined anywhere!');
    157:
    158:         self::$logger->debug('<<setBO');
    159:     }
    160:
    161:     /**
    162:      * Gets the BO attached to this view (if any)
    163:      *
    164:      * @return AlphaDAO
    165:      * @since 1.0
    166:      */
    167:     public function getBO() {
    168:         return $this->BO;
    169:     }
    170:
    171:     /**
    172:      * Renders the default create view to standard output
    173:      *
    174:      * @param array $fields Hash array of fields to pass to the template
    175:      * @since 1.0
    176:      */
    177:     public function createView($fields=array()) {
    178:         self::$logger->debug('>>createView(fields=['.var_export($fields, true).'])');
    179:
    180:         if(method_exists($this, 'before_createView_callback'))
    181:             $this->before_createView_callback();
    182:
    183:         global $config;
    184:
    185:         $body = $this->provider->createView($fields);
    186:
    187:         echo $body;
    188:
    189:         if(method_exists($this, 'after_createView_callback'))
    190:             $this->after_createView_callback();
    191:
    192:         self::$logger->debug('<<createView');
    193:     }
    194:
    195:     /**
    196:      * Renders a form to enable object editing to standard output
    197:      *
    198:      * @param array $fields Hash array of fields to pass to the template
    199:      * @since 1.0
    200:      */
    201:     public function editView($fields=array()) {
    202:         self::$logger->debug('>>editView(fields=['.var_export($fields, true).'])');
    203:
    204:         if(method_exists($this, 'before_editView_callback'))
    205:             $this->before_editView_callback();
    206:
    207:         global $config;
    208:
    209:         $body = $this->provider->editView($fields);
    210:
    211:         echo $body;
    212:
    213:         if(method_exists($this, 'after_editView_callback'))
    214:             $this->after_editView_callback();
    215:
    216:         self::$logger->debug('<<editView');
    217:     }
    218:
    219:     /**
    220:      * Renders the list view to standard output
    221:      *
    222:      * @param array $fields Hash array of fields to pass to the template
    223:      * @since 1.0
    224:      */
    225:     public function listView($fields=array()) {
    226:         self::$logger->debug('>>listView(fields=['.var_export($fields, true).'])');
    227:
    228:         if(method_exists($this, 'before_listView_callback'))
    229:             $this->before_listView_callback();
    230:
    231:         global $config;
    232:
    233:         $body = $this->provider->listView($fields);
    234:
    235:         echo $body;
    236:
    237:         if(method_exists($this, 'after_listView_callback'))
    238:             $this->after_listView_callback();
    239:
    240:         self::$logger->debug('<<listView');
    241:     }
    242:
    243:     /**
    244:      * Displays a detailed view of the object (read-only) to standard output
    245:      *
    246:      * @param array $fields Hash array of fields to pass to the template
    247:      * @since 1.0
    248:      */
    249:     public function detailedView($fields=array()) {
    250:         self::$logger->debug('>>detailedView(fields=['.var_export($fields, true).'])');
    251:
    252:         if(method_exists($this, 'before_detailedView_callback'))
    253:             $this->before_detailedView_callback();
    254:
    255:         global $config;
    256:
    257:         $body = $this->provider->detailedView($fields);
    258:
    259:         echo $body;
    260:
    261:         if(method_exists($this, 'after_detailedView_callback'))
    262:             $this->after_detailedView_callback();
    263:
    264:         self::$logger->debug('<<detailedView');
    265:     }
    266:
    267:     /**
    268:      * Renders the admin view for the business object screen to standard output
    269:      *
    270:      * @param array $fields Hash array of fields to pass to the template
    271:      * @since 1.0
    272:      */
    273:     public function adminView($fields=array()) {
    274:         self::$logger->debug('>>adminView(fields=['.var_export($fields, true).'])');
    275:
    276:         if(method_exists($this, 'before_adminView_callback'))
    277:             $this->before_adminView_callback();
    278:
    279:         global $config;
    280:
    281:         $body = $this->provider->adminView($fields);
    282:
    283:         echo $body;
    284:
    285:         if(method_exists($this, 'after_adminView_callback'))
    286:             $this->after_adminView_callback();
    287:
    288:         self::$logger->debug('<<adminView');
    289:     }
    290:
    291:     /**
    292:      * Method to render the page header content
    293:      *
    294:      * @param AlphaController $controller
    295:      * @return string
    296:      * @throws IllegalArguementException
    297:      * @since 1.0
    298:      */
    299:     public static function displayPageHead($controller) {
    300:         if(self::$logger == null)
    301:             self::$logger = new Logger('AlphaView');
    302:         self::$logger->debug('>>displayPageHead(controller=['.var_export($controller, true).'])');
    303:
    304:         if(method_exists($controller, 'before_displayPageHead_callback'))
    305:             $controller->before_displayPageHead_callback();
    306:
    307:         global $config;
    308:
    309:         $provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), new PersonObject());
    310:         eval('$header = '.get_class($provider).'::displayPageHead($controller);');
    311:
    312:         if(method_exists($controller, 'after_displayPageHead_callback'))
    313:             $header.= $controller->after_displayPageHead_callback();
    314:
    315:         self::$logger->debug('<<displayPageHead ['.$header.']');
    316:         return $header;
    317:     }
    318:
    319:     /**
    320:      * Method to render the page footer content
    321:      *
    322:      * @param AlphaController $controller
    323:      * @return string
    324:      * @since 1.0
    325:      */
    326:     public static function displayPageFoot($controller) {
    327:         if(self::$logger == null)
    328:             self::$logger = new Logger('AlphaView');
    329:
    330:         self::$logger->debug('>>displayPageFoot(controller=['.get_class($controller).'])');
    331:
    332:         global $config;
    333:
    334:         $footer = '';
    335:
    336:         if(method_exists($controller, 'before_displayPageFoot_callback'))
    337:             $footer .= $controller->before_displayPageFoot_callback();
    338:
    339:         $provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), new PersonObject());
    340:         eval('$footer .= '.get_class($provider).'::displayPageFoot($controller);');
    341:
    342:         if(method_exists($controller, 'after_displayPageFoot_callback'))
    343:             $footer .= $controller->after_displayPageFoot_callback();
    344:
    345:         self::$logger->debug('<<displayPageFoot ['.$footer.']');
    346:         return $footer;
    347:     }
    348:
    349:     /**
    350:      * Renders the content for an update (e.g. successful save) message
    351:      *
    352:      * @param string $message
    353:      * @return string
    354:      * @since 1.0
    355:      */
    356:     public static function displayUpdateMessage($message) {
    357:         if(self::$logger == null)
    358:             self::$logger = new Logger('AlphaView');
    359:         self::$logger->debug('>>displayUpdateMessage(message=['.$message.'])');
    360:
    361:         global $config;
    362:
    363:         $provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), new PersonObject());
    364:         eval('$message = '.get_class($provider).'::displayUpdateMessage($message);');
    365:
    366:         self::$logger->debug('<<displayUpdateMessage ['.$message.']');
    367:         return $message;
    368:     }
    369:
    370:     /**
    371:      * Renders the content for an error (e.g. save failed) message
    372:      *
    373:      * @param string $message
    374:      * @return string
    375:      * @since 1.0
    376:      */
    377:     public static function displayErrorMessage($message) {
    378:         if(self::$logger == null)
    379:             self::$logger = new Logger('AlphaView');
    380:         self::$logger->debug('>>displayErrorMessage(message=['.$message.'])');
    381:
    382:         global $config;
    383:
    384:         $provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), new PersonObject());
    385:         eval('$message = '.get_class($provider).'::displayErrorMessage($message);');
    386:
    387:         self::$logger->debug('<<displayErrorMessage ['.$message.']');
    388:         return $message;
    389:     }
    390:
    391:     /**
    392:      * Renders an error page with the supplied error code (typlically a HTTP code) and a message
    393:      *
    394:      * @param string $code
    395:      * @param string $message
    396:      * @return string
    397:      * @since 1.0
    398:      */
    399:     public static function renderErrorPage($code, $message) {
    400:         if(self::$logger == null)
    401:             self::$logger = new Logger('AlphaView');
    402:         self::$logger->debug('>>renderErrorPage(code=['.$code.'],message=['.$message.'])');
    403:
    404:         global $config;
    405:
    406:         $provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), new PersonObject());
    407:         eval('$message = '.get_class($provider).'::renderErrorPage($code, $message);');
    408:
    409:         self::$logger->debug('<<renderErrorPage ['.$message.']');
    410:         return $message;
    411:     }
    412:
    413:     /**
    414:      * Method to render a hidden HTML form for posting the OID of an object to be deleted
    415:      *
    416:      * @return string
    417:      * @since 1.0
    418:      */
    419:     public static function renderDeleteForm() {
    420:         if(self::$logger == null)
    421:             self::$logger = new Logger('AlphaView');
    422:         self::$logger->debug('>>renderDeleteForm()');
    423:
    424:         global $config;
    425:
    426:         $provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), new PersonObject());
    427:         eval('$html = '.get_class($provider).'::renderDeleteForm();');
    428:
    429:         self::$logger->debug('<<renderDeleteForm ['.$html.']');
    430:         return $html;
    431:     }
    432:
    433:     /**
    434:      * Method to render a HTML form with two hidden, hashed (MD5) form fields to be used as
    435:      * a check to ensure that a post to the controller is being sent from the same server
    436:      * as hosting it.
    437:      *
    438:      * @return string
    439:      * @since 1.0
    440:      */
    441:     public static function renderSecurityFields() {
    442:         if(self::$logger == null)
    443:             self::$logger = new Logger('AlphaView');
    444:         self::$logger->debug('>>renderSecurityFields()');
    445:
    446:         global $config;
    447:
    448:         $provider = AlphaRendererProviderFactory::getInstance($config->get('app.renderer.provider.name'), new PersonObject());
    449:         eval('$html = '.get_class($provider).'::renderSecurityFields();');
    450:
    451:         self::$logger->debug('<<renderSecurityFields ['.$html.']');
    452:         return $html;
    453:     }
    454:
    455:     /**
    456:      * Method to render the default Integer HTML
    457:      *
    458:      * @param string $name The field name
    459:      * @param string $label The label to apply to the field
    460:      * @param string $mode The field mode (create/edit/view)
    461:      * @param string $value The field value (optional)
    462:      * @param bool $tableTags Include table tags and label (optional)
    463:      * @return string
    464:      * @since 1.0
    465:      */
    466:     public function renderIntegerField($name, $label, $mode, $value='', $tableTags=true) {
    467:         self::$logger->debug('>>renderIntegerField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
    468:
    469:         global $config;
    470:
    471:         $html = $this->provider->renderIntegerField($name, $label, $mode, $value, $tableTags);
    472:
    473:         self::$logger->debug('<<renderIntegerField ['.$html.']');
    474:         return $html;
    475:     }
    476:
    477:     /**
    478:      * Method to render the default Double HTML
    479:      *
    480:      * @param string $name The field name
    481:      * @param string $label The label to apply to the field
    482:      * @param string $mode The field mode (create/edit/view)
    483:      * @param string $value The field value (optional)
    484:      * @param bool $tableTags Include table tags and label (optional)
    485:      * @return string
    486:      * @since 1.0
    487:      */
    488:     public static function renderDoubleField($name, $label, $mode, $value='', $tableTags=true) {
    489:         self::$logger->debug('>>renderDoubleField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
    490:
    491:         global $config;
    492:
    493:         $html = $this->provider->renderDoubleField($name, $label, $mode, $value, $tableTags);
    494:
    495:         self::$logger->debug('<<renderDoubleField ['.$html.']');
    496:         return $html;
    497:     }
    498:
    499:     /**
    500:      * Method to render the default Boolean HTML
    501:      *
    502:      * @param string $name The field name
    503:      * @param string $label The label to apply to the field
    504:      * @param string $mode The field mode (create/edit/view)
    505:      * @param string $value The field value (optional)
    506:      * @param bool $tableTags Include table tags and label (optional)
    507:      * @return string
    508:      * @since 1.0
    509:      */
    510:     public function renderBooleanField($name, $label, $mode, $value='', $tableTags=true) {
    511:         self::$logger->debug('>>renderBooleanField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
    512:
    513:         global $config;
    514:
    515:         $html = $this->provider->renderBooleanField($name, $label, $mode, $value, $tableTags);
    516:
    517:         self::$logger->debug('<<renderBooleanField ['.$html.']');
    518:         return $html;
    519:     }
    520:
    521:     /**
    522:      * Method to render the default Enum HTML
    523:      *
    524:      * @param string $name The field name
    525:      * @param string $label The label to apply to the field
    526:      * @param string $mode The field mode (create/edit/view)
    527:      * @param array $options The Enum options
    528:      * @param string $value The field value (optional)
    529:      * @param bool $tableTags Include table tags and label (optional)
    530:      * @return string
    531:      * @since 1.0
    532:      */
    533:     public static function renderEnumField($name, $label, $mode, $options, $value='', $tableTags=true) {
    534:         self::$logger->debug('>>renderEnumField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
    535:
    536:         global $config;
    537:
    538:         $html = $this->provider->renderEnumField($name, $label, $mode, $options, $value, $tableTags);
    539:
    540:         self::$logger->debug('<<renderEnumField ['.$html.']');
    541:         return $html;
    542:     }
    543:
    544:     /**
    545:      * Method to render the default DEnum HTML
    546:      *
    547:      * @param string $name The field name
    548:      * @param string $label The label to apply to the field
    549:      * @param string $mode The field mode (create/edit/view)
    550:      * @param array $options The DEnum options
    551:      * @param string $value The field value (optional)
    552:      * @param bool $tableTags Include table tags and label (optional)
    553:      * @return string
    554:      * @since 1.0
    555:      */
    556:     public static function renderDEnumField($name, $label, $mode, $options, $value='', $tableTags=true) {
    557:         self::$logger->debug('>>renderDEnumField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
    558:
    559:         global $config;
    560:
    561:         $html = $this->provider->renderDEnumField($name, $label, $mode, $options, $value, $tableTags);
    562:
    563:         self::$logger->debug('<<renderDEnumField ['.$html.']');
    564:         return $html;
    565:     }
    566:
    567:     /**
    568:      * Method to render the default field HTML when type is not known
    569:      *
    570:      * @param string $name The field name
    571:      * @param string $label The label to apply to the field
    572:      * @param string $mode The field mode (create/edit/view)
    573:      * @param string $value The field value (optional)
    574:      * @param bool $tableTags Include table tags and label (optional)
    575:      * @return string
    576:      * @since 1.0
    577:      */
    578:     public function renderDefaultField($name, $label, $mode, $value='', $tableTags=true) {
    579:         self::$logger->debug('>>renderDefaultField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
    580:
    581:         global $config;
    582:
    583:         $html = $this->provider->renderDefaultField($name, $label, $mode, $value, $tableTags);
    584:
    585:         self::$logger->debug('<<renderDefaultField ['.$html.']');
    586:         return $html;
    587:     }
    588:
    589:     /**
    590:      * render the default Text HTML
    591:      *
    592:      * @param string $name The field name
    593:      * @param string $label The label to apply to the field
    594:      * @param string $mode The field mode (create/edit/view)
    595:      * @param string $value The field value (optional)
    596:      * @param bool $tableTags Include table tags and label (optional)
    597:      * @return string
    598:      * @since 1.0
    599:      */
    600:     public function renderTextField($name, $label, $mode, $value='', $tableTags=true) {
    601:         self::$logger->debug('>>renderTextField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'])');
    602:
    603:         global $config;
    604:
    605:         $html = $this->provider->renderTextField($name, $label, $mode, $value, $tableTags);
    606:
    607:         self::$logger->debug('<<renderTextField ['.$html.']');
    608:         return $html;
    609:     }
    610:
    611:     /**
    612:      * render the default Relation HTML
    613:      *
    614:      * @param string $name The field name
    615:      * @param string $label The label to apply to the field
    616:      * @param string $mode The field mode (create/edit/view)
    617:      * @param string $value The field value (optional)
    618:      * @param bool $tableTags Include table tags and label (optional)
    619:      * @param bool $expanded Render the related fields in expanded format or not (optional)
    620:      * @param bool $buttons Render buttons for expanding/contacting the related fields (optional)
    621:      * @return string
    622:      * @since 1.0
    623:      */
    624:     public function renderRelationField($name, $label, $mode, $value='', $tableTags=true, $expanded=false, $buttons=true) {
    625:         self::$logger->debug('>>renderRelationField(name=['.$name.'], label=['.$label.'], mode=['.$mode.'], value=['.$value.'], tableTags=['.$tableTags.'], expanded=['.$expanded.'], buttons=['.$buttons.'])');
    626:
    627:         global $config;
    628:
    629:         $html = $this->provider->renderRelationField($name, $label, $mode, $value, $tableTags, $expanded, $buttons);
    630:
    631:         self::$logger->debug('<<renderRelationField ['.$html.']');
    632:         return $html;
    633:     }
    634:
    635:     /**
    636:      * Renders all fields for the current BO in edit/create/view mode
    637:      *
    638:      * @param string $mode (view|edit|create)
    639:      * @param array $filterFields Optional list of field names to exclude from rendering
    640:      * @param array $readOnlyFields Optional list of fields to render in a readonly fashion when rendering in create or edit mode
    641:      * @return string
    642:      * @since 1.0
    643:      */
    644:     public function renderAllFields($mode, $filterFields=array(), $readOnlyFields=array()) {
    645:         self::$logger->debug('>>renderAllFields(mode=['.$mode.'], filterFields=['.var_export($filterFields, true).'], readOnlyFields=['.var_export($readOnlyFields, true).'])');
    646:
    647:         global $config;
    648:
    649:         $html = $this->provider->renderAllFields($mode, $filterFields, $readOnlyFields);
    650:
    651:         self::$logger->debug('<<renderAllFields ['.$html.']');
    652:         return $html;
    653:     }
    654:
    655:     /**
    656:      * Loads a template for the BO specified if one exists.  Lower level custom templates
    657:      * take precedence.
    658:      *
    659:      * @param AlphaDAO $BO
    660:      * @param string $mode
    661:      * @param array $fields
    662:      * @since 1.0
    663:      * @throws IllegalArguementException
    664:      */
    665:     public static function loadTemplate($BO, $mode, $fields) {
    666:         self::$logger->debug('>>loadTemplate(BO=['.var_export($BO, true).'], mode=['.$mode.'], fields=['.var_export($fields, true).'])');
    667:
    668:         global $config;
    669:
    670:         // for each BO property, create a local variable holding its value
    671:         $reflection = new ReflectionClass(get_class($BO));
    672:         $properties = $reflection->getProperties();
    673:
    674:         foreach($properties as $propObj) {
    675:             $propName = $propObj->name;
    676:
    677:             if($propName != 'logger' && !$propObj->isPrivate()) {
    678:                 $prop = $BO->getPropObject($propName);
    679:                 if($prop instanceof DEnum) {
    680:                     ${$propName} = $BO->getPropObject($propName)->getDisplayValue();
    681:                 }else{
    682:                     ${$propName} = $BO->get($propName);
    683:                 }
    684:             }
    685:         }
    686:
    687:         // loop over the $fields array and create a local variable for each key value
    688:         foreach (array_keys($fields) as $fieldName)
    689:             ${$fieldName} = $fields[$fieldName];
    690:
    691:         $filename = $mode.'.phtml';
    692:         $classTemplateDir = get_class($BO);
    693:
    694:         $customPath = $config->get('app.root').'view/html/templates/'.$classTemplateDir.'/'.$filename;
    695:         $defaultPath1 = $config->get('app.root').'alpha/view/renderers/html/templates/'.$classTemplateDir.'/'.$filename;
    696:         $defaultPath2 = $config->get('app.root').'alpha/view/renderers/html/templates/'.$filename;
    697:
    698:         // Check to see if a custom template exists for this BO, and if it does load that
    699:         if (file_exists($customPath)) {
    700:             self::$logger->debug('Loading template ['.$customPath.']');
    701:             require $customPath;
    702:         }elseif (file_exists($defaultPath1)) {
    703:             self::$logger->debug('Loading template ['.$defaultPath1.']');
    704:             require $defaultPath1;
    705:         }elseif (file_exists($defaultPath2)) {
    706:             self::$logger->debug('Loading template ['.$defaultPath2.']');
    707:             require $defaultPath2;
    708:         }else{
    709:             throw new IllegalArguementException('No ['.$mode.'] HTML template found for class ['.get_class($BO).']');
    710:         }
    711:
    712:         self::$logger->debug('<<loadTemplate');
    713:     }
    714:
    715:     /**
    716:      * Loads a template fragment from the renderers/[type]/fragments/[filename.ext] location.
    717:      *
    718:      * @param string $type Currently only html supported, later json and xml.
    719:      * @param string $fileName The name of the fragment file
    720:      * @param array $fields A hash array of field values to pass to the template fragment.
    721:      * @since 1.2
    722:      * @throws IllegalArguementException
    723:      */
    724:     public static function loadTemplateFragment($type, $fileName, $fields) {
    725:         if(self::$logger == null)
    726:             self::$logger = new Logger('AlphaView');
    727:         self::$logger->debug('>>loadTemplateFragment(type=['.$type.'], fileName=['.$fileName.'], fields=['.var_export($fields, true).'])');
    728:
    729:         global $config;
    730:
    731:         // loop over the $fields array and create a local variable for each key value
    732:         foreach (array_keys($fields) as $fieldName)
    733:             ${$fieldName} = $fields[$fieldName];
    734:
    735:         $customPath = $config->get('app.root').'view/'.$type.'/fragments/'.$fileName;
    736:         $defaultPath = $config->get('app.root').'alpha/view/renderers/'.$type.'/fragments/'.$fileName;
    737:
    738:         // Check to see if a custom template exists for this BO, and if it does load that
    739:         if (file_exists($customPath)) {
    740:             self::$logger->debug('Loading template ['.$customPath.']');
    741:             require $customPath;
    742:         }elseif (file_exists($defaultPath)) {
    743:             self::$logger->debug('Loading template ['.$defaultPath.']');
    744:             require $defaultPath;
    745:         }else{
    746:             throw new IllegalArguementException('Template fragment not found in ['.$customPath.'] or ['.$defaultPath.']!');
    747:         }
    748:
    749:         self::$logger->debug('<<loadTemplateFragment');
    750:     }
    751:
    752:     /**
    753:          * Enables you to set an explicit type of AlphaRendererProviderInterface implementation to use for rendering the business
    754:      * object attached to this view.  Note that this has no affect on static methods of the AlphaView class, which always instantiate
    755:      * a new AlphaRendererProviderInterface provider each time they're called.
    756:          *
    757:          * @param string $ProviderClassName The name of the AlphaRendererProviderInterface implementation to use in this view object
    758:          * @since 1.2
    759:          * @throws IllegalArguementException
    760:          */
    761:     public function setProvider($ProviderClassName) {
    762:         $this->provider = AlphaRendererProviderFactory::getInstance($ProviderClassName, $this->BO);
    763:     }
    764: }
    765:
    766: ?>
    767: