Source for file ViewMapper.php

Documentation is available at ViewMapper.php

  1. <?php
  2.     /**
  3.      * View Mapper Classes
  4.      *
  5.      * @copyright Copyright (c) 2007 Mirchev Ideas Ltd. All rights reserved.
  6.      * @package MIPHPF
  7.      */
  8.     
  9.     /**
  10.      * The view mapper controller class
  11.      *
  12.      * @copyright Copyright (c) 2007 Mirchev Ideas Ltd. All rights reserved.
  13.      * @package MIPHPF
  14.      */
  15.     class miViewMapperController {
  16.         protected $_view;
  17.         protected $_viewMappers = array();
  18.         
  19.         /**
  20.          * Constructs the object
  21.          * 
  22.          * @param miView $view 
  23.          * @param miRecord $record 
  24.          */
  25.         public function __construct(miView $view)
  26.         {
  27.             $this->_view = $view;
  28.             
  29.             $this->setupViewMappers();
  30.         }
  31.         
  32.         /**
  33.          * Create all view mapper objects
  34.          */
  35.         protected function setupViewMappers()
  36.         {
  37.             $dataFields = $this->_view->getDataFields();
  38.             $viewMappers = array();
  39.             foreach ($dataFields as $dataField) {
  40.                 if (isset($dataField['modelStrategy']))
  41.                     $viewMappers[] = $dataField['modelStrategy'];
  42.             }
  43.             foreach ($viewMappers as $viewMapper)
  44.                 $this->addViewMapper($viewMapper, new $viewMapper($this));
  45.         }
  46.         
  47.         /**
  48.          * Return the view
  49.          * 
  50.          * @return miView the view object
  51.          */
  52.         public function getView()
  53.         {
  54.             return $this->_view;
  55.         }
  56.         
  57.         /**
  58.          * Adds new view mapper object
  59.          * 
  60.          * @param string $viewMapperName view mapper name
  61.          * @param miViewMapper $viewMapper the view mapper object
  62.          */
  63.         public function addViewMapper($viewMapperName, miViewMapper $viewMapper)
  64.         {
  65.             $this->_viewMappers[$viewMapperName] = $viewMapper;
  66.         }
  67.         
  68.         /**
  69.          * Returns the view mapper with name $viewMapperName
  70.          * 
  71.          * @param string $viewMapperName the view mapper name (optional). If not given returns the default view mapper
  72.          * @return miViewMapper object
  73.          */
  74.         public function getViewMapper($viewMapperName = '')
  75.         {
  76.             return $this->_viewMappers[$viewMapperName];
  77.         }
  78.         
  79.         /**
  80.          * Updates the form with the newly submitted values
  81.          * 
  82.          * @param miWebForm $webForm 
  83.          */
  84.         public function updateSubmittedForm(miWebForm $webForm)
  85.         {
  86.             $formData = $webForm->getSubmittedDataRow();
  87.             $webForm->setFormDataRow($formData);
  88.         }
  89.         
  90.         /**
  91.          * Call all view mappers
  92.          * 
  93.          * @param string $operation 'read', 'insert', 'update', 'preDelete' or 'delete'
  94.          */
  95.         protected function callViewMappers($operation)
  96.         {
  97.             foreach ($this->_viewMappers as $viewMapper)
  98.                 call_user_func(array($viewMapper, $operation));
  99.         }
  100.         
  101.         public function read()
  102.         {
  103.             $this->callViewMappers('read');
  104.         }
  105.         
  106.         public function insert()
  107.         {
  108.             $this->callViewMappers('insert');
  109.         }
  110.         public function update()
  111.         {
  112.             $this->callViewMappers('update');
  113.         }
  114.         public function delete()
  115.         {
  116.             $this->callViewMappers('preDelete');
  117.             $this->callViewMappers('delete');
  118.         }
  119.     }
  120.     
  121.     
  122.     /**
  123.      * Default View to Domain Object Mapper Controller
  124.      * 
  125.      * @copyright Copyright (c) 2007 Mirchev Ideas Ltd. All rights reserved.
  126.      * @package MIPHPF
  127.      */
  128.     class miViewMapperControllerDefault extends miViewMapperController {
  129.         protected $_domainObj;
  130.         protected $_webForm = null;
  131.         
  132.         public function __construct(miView $view, miDomainObject $domainObj, $pkValue)
  133.         {
  134.             $this->_domainObj = $domainObj;
  135.             $this->addViewMapper('', new miViewMapperDefault($this, $domainObj, $pkValue));
  136.             
  137.             parent::__construct($view);
  138.         }
  139.         
  140.         public function getDomainObject()
  141.         {
  142.             return $this->_domainObj;
  143.         }
  144.         
  145.         public function setWebForm($webForm)
  146.         {
  147.             $this->_webForm = $webForm;
  148.         }
  149.         
  150.         public function getWebForm()
  151.         {
  152.             return $this->_webForm;
  153.         }
  154.         
  155.         public function getProperies($fieldName)
  156.         {
  157.             $dataFields = $this->_view->getDataFields();
  158.             foreach ($dataFields as $dataField)
  159.                 if ($dataField['data'] == $fieldName)
  160.                     return $dataField['properties'];
  161.             throw new miException(sprintf('Cannot find properties for %s', $fieldName));
  162.         }
  163.         
  164.         public function getViewMapperDataFields($viewMapperName)
  165.         {
  166.             $result = array();
  167.             $dataFields = $this->_view->getDataFields();
  168.             foreach ($dataFields as $dataField)
  169.                 if (isset($dataField['modelStrategy']) and ($dataField['modelStrategy'] == $viewMapperName))
  170.                     $result[] = $dataField;
  171.             return $result;
  172.         }
  173.         
  174.         /**
  175.          * Retrieve the data from the web form
  176.          */
  177.         public function setDataFromWebForm()
  178.         {
  179.             $formData = $this->_webForm->getSubmittedDataRow();
  180.             $dataFields = $this->_view->getDataFields();
  181.             foreach ($dataFields as $dataField) {
  182.                 if (!isset($formData[$dataField['data']]))
  183.                     continue;
  184.                 
  185.                 $viewMapperName = isset($dataField['modelStrategy']) ? $dataField['modelStrategy'] : '';
  186.                 $viewMapper = $this->_viewMappers[$viewMapperName];
  187.                 $viewMapper->set($dataField['data'], $formData[$dataField['data']]);
  188.             }
  189.         }
  190.         
  191.         /**
  192.          * Set the data to the web form
  193.          */
  194.         public function setDataToWebForm()
  195.         {
  196.             $dataFields = $this->_view->getDataFields();
  197.             foreach ($dataFields as $dataField) {
  198.                 $viewMapperName = isset($dataField['modelStrategy']) ? $dataField['modelStrategy'] : '';
  199.                 $viewMapper = $this->_viewMappers[$viewMapperName];
  200.                 $this->_webForm->setFormData($dataField['data'], $viewMapper->get($dataField['data']));
  201.             }
  202.         }
  203.     }
  204.     
  205.     /**
  206.      * The View Mapper base class
  207.      *
  208.      * @copyright Copyright (c) 2007 Mirchev Ideas Ltd. All rights reserved.
  209.      * @package MIPHPF
  210.      */
  211.     class miViewMapper {
  212.         protected $_viewMapperController;
  213.         
  214.         public function __construct(miViewMapperController $viewMapperController)
  215.         {
  216.             $this->_viewMapperController = $viewMapperController;
  217.         }
  218.         
  219.         public function getViewMapperController()
  220.         {
  221.             return $this->_viewMapperController;
  222.         }
  223.         
  224.         public function get($fieldName) {}
  225.         public function set($fieldName, $fieldValue) {}
  226.         
  227.         public function read() {}
  228.         public function insert() {}
  229.         public function update() {}
  230.         public function delete() {}
  231.         
  232.         public function preDelete() { return true; }
  233.     }
  234.     
  235.     /**
  236.      * The view to domain object mapper default class
  237.      *
  238.      * @copyright Copyright (c) 2007 Mirchev Ideas Ltd. All rights reserved.
  239.      * @package MIPHPF
  240.      */
  241.     class miViewMapperDefault extends miViewMapper {
  242.         protected $_domainObj;
  243.         protected $_pkValue;
  244.         
  245.         public function __construct(miViewMapperController $viewMapperController, miDomainObject $domainObj, $pkValue)
  246.         {
  247.             parent::__construct($viewMapperController);
  248.             $this->_domainObj = $domainObj;
  249.             $this->_pkValue = $pkValue;
  250.         }
  251.         
  252.         public function getDomainObject()
  253.         {
  254.             return $this->_domainObj;
  255.         }
  256.         
  257.         public function get($fieldName)
  258.         {
  259.             return $this->_domainObj->get($fieldName);
  260.         }
  261.         
  262.         public function set($fieldName, $fieldValue)
  263.         {
  264.             $this->_domainObj->set($fieldName, $fieldValue);
  265.         }
  266.         
  267.         /**
  268.          * Read the model data from storage
  269.          */
  270.         public function read()
  271.         {
  272.             $this->_domainObj->read($this->_pkValue);
  273.         }
  274.         
  275.         /**
  276.          * Insert the model data as new record
  277.          */
  278.         public function insert()
  279.         {
  280.             return $this->_domainObj->insert();
  281.         }
  282.         
  283.         /**
  284.          * Update existing record
  285.          */
  286.         public function update()
  287.         {
  288.             return $this->_domainObj->update();
  289.         }
  290.         
  291.         /**
  292.          * Delete existing record
  293.          */
  294.         public function delete()
  295.         {
  296.             return $this->_domainObj->delete($this->_pkValue);
  297.         }
  298.     }
  299. ?>

Documentation generated on Thu, 08 May 2008 16:57:58 +0300 by phpDocumentor 1.4.1