Source for file Abstract_Singleton_Model.php

Documentation is available at Abstract_Singleton_Model.php

  1. <?php
  2. /**
  3.  *    LAIKA FRAMEWORK Release Notes:
  4.  *
  5.  *    @filesource     Abstract_Singleton_Model.php
  6.  *
  7.  *    @version        0.1.0b
  8.  *    @package        Laika
  9.  *    @subpackage     core
  10.  *    @category       abstract
  11.  *    @date           2012-05-18 21:48:30 -0400 (Fri, 18 May 2012)
  12.  *
  13.  *    @author         Leonard M. Witzel <witzel@post.harvard.edu>
  14.  *    @copyright      Copyright (c) 2012  Laika Soft <{@link http://oafbot.com}>
  15.  *
  16.  */
  17. /**
  18.  * Abstract Laika_Abstract_Singleton_Model class.
  19.  * 
  20.  * @abstract
  21.  * @extends Laika_Singleton
  22.  */
  23. abstract class Laika_Abstract_Singleton_Model extends Laika_Singleton implements Laika_Interface_Model{
  24.  
  25.     protected static $instance;
  26.     protected        $model;
  27.     protected        $table;
  28.     protected        $accessibles = array();
  29.         
  30.     protected        $id;
  31.     protected        $created;
  32.     protected        $updated;
  33.  
  34. //-------------------------------------------------------------------
  35. //    CONSTRUCTOR
  36. //-------------------------------------------------------------------
  37.  
  38.     /**
  39.      * init function.
  40.      * 
  41.      * @access public
  42.      * @static
  43.      * @return void 
  44.      */
  45.     public static function init(){        
  46.         $m = parent::init();
  47.         $class = get_class($m);
  48.         
  49.         if(is_int(strpos($class,CODE_NAME)))
  50.             $m->model = str_replace(CODE_NAME.'_', "", $class, $count = 1);
  51.         else
  52.             $m->model = str_replace(NAME_SPACE, "", $class, $count = 1);        
  53.         $m->table = strtolower($m->model)."s";
  54.         
  55.         return $m;    
  56.     }
  57.  
  58.  
  59. //-------------------------------------------------------------------
  60. //    SETTER & GETTER METHODS
  61. //-------------------------------------------------------------------
  62.     /**
  63.      * dbset function.
  64.      * 
  65.      * @access public
  66.      * @param  string $property 
  67.      * @param  mixed  $value 
  68.      * @return void 
  69.      */
  70.     public function dset($property,$value){
  71.  
  72.         static::init()->$property = $value;
  73.  
  74.         $table = static::init()->table;
  75.         $id    = static::init()->id; 
  76.         
  77.         Laika_Database::update($table, $property, $value, "id = $id");
  78.     }
  79.         
  80.     /**
  81.      * dbget function.
  82.      * 
  83.      * @access public
  84.      * @param  string $property 
  85.      * @return mixed 
  86.      */
  87.     public function dget($property){
  88.         
  89.         $table  = static::init()->table;
  90.         $id     = static::init()->id;
  91.         $result = Laika_Database::select_where($property, $table, "id = $id");
  92.         
  93.         static::init()->$property = $result[$property];
  94.         
  95.         return $result[$property];
  96.     }
  97.  
  98.     
  99. //-------------------------------------------------------------------
  100. //    METHODS
  101. //-------------------------------------------------------------------
  102.     /**
  103.      * load function.
  104.      * 
  105.      * @access public
  106.      * @static
  107.      * @param mixed $id 
  108.      * @return void 
  109.      */
  110.     public static function load($id){
  111.         $class = get_called_class();
  112.         $m =  $class::init();
  113.         $table = $m->table;
  114.         
  115.         $result = Laika_Database::select_by($id,$table);
  116.  
  117.         $model = get_class_vars(get_class($m));
  118.         $count = count($model);
  119.         
  120.         foreach ($model as $property => $value)            
  121.             if($property != 'instance' && $property != 'model' && $property != 'table' && $property != 'accessibles')
  122.                $m->$property = $result[$property];
  123.         return $m;
  124.     }
  125.     
  126.     /**
  127.      * find function.
  128.      * 
  129.      *
  130.      * @access public
  131.      * @static
  132.      * @param mixed $param 
  133.      * @param mixed $value 
  134.      * @return void 
  135.      */
  136.     public static function find($param,$value){
  137.         $table = self::init()->table;
  138.         $result = Laika_Database::select_where('id', $table, "$param = '$value'");
  139.         return self::load($result['id']);
  140.     }
  141.     
  142.     /**
  143.      * map_to_string function.
  144.      * 
  145.      * @access public
  146.      * @static
  147.      * @param mixed $ignore_id 
  148.      * @return void 
  149.      */
  150.     public static function map_to_string($ignore_id){
  151.         $columns = self::get_map();
  152.         if($ignore_id)
  153.             foreach($columns as $key => $value)
  154.                 if($value != 'id')
  155.                     $string[] = $value;  
  156.         return implode(',',$string);
  157.     }
  158.  
  159.     /**
  160.      * get_map function.
  161.      * 
  162.      * @access public
  163.      * @static
  164.      * @return void 
  165.      */
  166.     public static function get_map(){           
  167.         $full_map = Laika_Database::show(self::init()->table);
  168.         foreach($full_map as $array => $column)
  169.             foreach($column as $key => $value)
  170.                 if($key == 'Field')
  171.                     $map[] = $value;
  172.         return $map;
  173.     }    
  174.     
  175.     /**
  176.      * add function.
  177.      * 
  178.      * @access public
  179.      * @static
  180.      * @return void 
  181.      */
  182.     public static function add(){
  183.         $class = get_called_class();
  184.         Laika_Database::add($class::init());
  185.     }
  186.      
  187.     /**
  188.      * delete function.
  189.      * 
  190.      * @access public
  191.      * @static
  192.      * @param mixed $object 
  193.      * @return void 
  194.      */
  195.     public static function delete($object){
  196.         Laika_Database::delete($object->table,$object->id);
  197.     }
  198.         
  199. /*
  200.     public static function create(){
  201.         Laika_Database::create(self::init()->table);
  202.     }
  203.     public static function drop(){}
  204.     public static function update(){}
  205. */
  206.     
  207.     /**
  208.      * count function.
  209.      * 
  210.      * @access public
  211.      * @static
  212.      * @return void 
  213.      */
  214.     public static function count(){
  215.         $table = self::init()->table;
  216.  
  217.         if(func_num_args()>0):
  218.             $conditions =  self::prep_conditions(func_get_arg(0));
  219.             $result = Laika_Database::count($table,$conditions);
  220.         else:
  221.             $result = Laika_Database::count($table);
  222.         endif;
  223.         return (int)array_pop(array_pop($result));
  224.     }    
  225.     
  226.     /**
  227.      * last function.
  228.      * 
  229.      * @access public
  230.      * @static
  231.      * @return void 
  232.      */
  233.     public static function last(){
  234.         $args = func_get_args();
  235.         $table = self::init()->table;
  236.         if(isset($args[0]) && $args[0] > 1)       
  237.             return Laika_Database::last($table,$args[0]);
  238.         else
  239.             return Laika_Database::last($table,1);
  240.     }
  241.     
  242.     /**
  243.      * first function.
  244.      * 
  245.      * @access public
  246.      * @static
  247.      * @return void 
  248.      */
  249.     public static function first(){
  250.         $args = func_get_args();
  251.         $table = self::init()->table;
  252.         if(isset($args[0]) && $args[0] > 1)       
  253.             return Laika_Database::first($table,$args[0]);
  254.         else
  255.             return Laika_Database::first($table,1);
  256.     }
  257.     
  258.     /**
  259.      * offset function.
  260.      * 
  261.      * @access public
  262.      * @static
  263.      * @param mixed $offset 
  264.      * @param mixed $limit 
  265.      * @return void 
  266.      */
  267.     public static function offset(){
  268.         $num = func_num_args();
  269.         $args = func_get_args();
  270.         switch($num){
  271.             case 0:
  272.                 $offset = 0;
  273.                 $limit  = 10;
  274.                 $column = '*';
  275.                 break;
  276.             case 1:
  277.                 $offset = $args[0];
  278.                 //$limit  = 'ALL';
  279.                 $limit = self::count();
  280.                 $column = '*';
  281.                 break;
  282.             case 2:
  283.                 $offset = $args[0];
  284.                 $limit  = $args[1];
  285.                 $column = '*'; 
  286.                 break;
  287.             case 3:
  288.                 $offset = $args[0];
  289.                 $limit  = $args[1];
  290.                 $column = $args[2];
  291.                 break;
  292.         }
  293.         $table = self::init()->table;
  294.         return Laika_Database::offset($table,$column,$limit,$offset);
  295.     }   
  296.  
  297.     
  298.     /**
  299.      * find_with_offset function.
  300.      * 
  301.      * @access public
  302.      * @static
  303.      * @param mixed $params 
  304.      * @param mixed $offset 
  305.      * @param mixed $limit 
  306.      * @return void 
  307.      */
  308.     public static function find_with_offset($params,$offset,$limit){
  309.         $table = self::init()->table;
  310.         $conditions = $model::prep_conditions($params);
  311.                         
  312.         return Laika_Database::find_with_offset($conditions,$table,$limit,$offset);
  313.     }    
  314.  
  315.  
  316.     /**
  317.      * prep_conditions function.
  318.      * 
  319.      * @access public
  320.      * @static
  321.      * @param mixed $params 
  322.      * @return void 
  323.      */
  324.     public static function prep_conditions($params){
  325.         $c = 0;
  326.         foreach($params as $k => $v):
  327.             ($c>0) ? $cond .= " AND $k = '$v'" : $cond = "$k = '$v'";
  328.             $c++;
  329.         endforeach;
  330.                 
  331.         return $cond;    
  332.     }
  333.  
  334.     
  335.     /**
  336.      * paginate function.
  337.      * 
  338.      * @access public
  339.      * @static
  340.      * @param int $limit 
  341.      * @return void 
  342.      */
  343.     public static function paginate(){
  344.         $num = func_num_args();
  345.         $model = self::init()->model;
  346.         $offset = $model.'_offset';
  347.         
  348.         if( !isset($_SESSION[$offset]) )
  349.             $_SESSION[$offset] = 0;
  350.                 
  351.         if($num==1):
  352.             $limit = func_get_arg(0);            
  353.             $results = self::offset($_SESSION[$offset],$limit);
  354.             $_SESSION[$offset] += $limit;
  355.         elseif($num>1):
  356.             $limit = func_get_arg(0);
  357.             $param = func_get_arg(1);
  358.             $value = func_get_arg(2);
  359.             $results = self::find_with_offset($where,$_SESSION[$offset],$limit);
  360.         else:
  361.             $results = self::offset($_SESSION[$offset]);
  362.         endif;
  363.         
  364.         return self::collection($results);
  365.     }
  366.         
  367.     /**
  368.      * collection function.
  369.      * 
  370.      * @access public
  371.      * @static
  372.      * @param mixed $array 
  373.      * @return void 
  374.      */
  375.     public static function collection($array){
  376.         $collection = new Laika_Collection();
  377.         foreach($array as $key => $value)
  378.             if(is_array($value))
  379.                 $collection[] = new Laika_Collectable(self::from_array($value));
  380.         return $collection;    
  381.     }
  382.     
  383.     /**
  384.      * accessible function.
  385.      * 
  386.      * @access public
  387.      * @static
  388.      * @return void 
  389.      */
  390.     public static function accessible(){
  391.         $accessibles = self::init()->accessibles;
  392.         foreach($accessibles as $key => $value)
  393.             $response[$value] = self::init()->$value;
  394.         return $response;
  395.     }
  396.         
  397.     //public static function populate(){}
  398.     
  399.     
  400.     public function created_to_date(){
  401.        return Laika_Time::database_to_date(self::init()->created);
  402.     }
  403.     public function created_to_shortdate(){
  404.        return Laika_Time::database_to_shortdate(self::init()->created);
  405.     }
  406.     public function created_to_datetime(){
  407.         return Laika_Time::database_to_datetime(self::init()->created);
  408.     }
  409.     public function created_to_time(){
  410.         return Laika_Time::database_to_time(self::init()->created);
  411.     }
  412.     
  413.     public function updated_to_date(){
  414.         return Laika_Time::database_to_date(self::init()->updated);
  415.     }
  416.     public function updated_to_shortdate(){
  417.         return Laika_Time::database_to_shortdate(self::init()->updated);    
  418.     }
  419.     public function updated_to_datetime(){
  420.         return Laika_Time::database_to_datetime(self::init()->updated);
  421.     }
  422.     public function updated_to_time(){
  423.         return Laika_Time::database_to_time(self::init()->updated);
  424.     }
  425.  
  426.     /**
  427.      * exists function.
  428.      * 
  429.      * @access public
  430.      * @param mixed $conditions 
  431.      * @return void 
  432.      */
  433.     public function exists($conditions){
  434.         if(self::count($conditions))
  435.             return true;
  436.         return false;
  437.     }    
  438. }

Documentation generated on Sat, 19 May 2012 02:16:55 -0400 by phpDocumentor 1.4.4