Record.php

Go to the documentation of this file.

<?php
 
namespace Rsi\Fred\Controller\Provider;
 
use \Rsi\Fred\Controller;
 
class Record extends \Rsi\Fred\Controller\Provider{
 
  public $data = null;
  public $search = []; //!< Custom search (key = column, value = callback function - params: the value for the column in the
    // record, the searched value(s), and the complete record; return true on match).
 
  protected $_cache = [];
 
  protected function data($params){
    if(is_callable($data = $this->data)){
      if(!array_key_exists($key = 'data-' . md5(serialize($params)),$this->_cache)) $this->_cache[$key] = call_user_func($data,$params,$this->id);
      $data = $this->_cache[$key];
    }
    return $data;
  }
 
  public function trans($column,$key,$value,$params = null){
    if(\Rsi::nothing($value)) return null;
    foreach($this->data($params) as $record) if(array_key_exists($key,$record) && ($record[$key] == $value)) return $record[$column] ?? null;
    return false;
  }
 
  public function exists($key,$value,$params = null){
    foreach($this->data($params) as $record) if(array_key_exists($key,$record) && ($record[$key] == $value)) return true;
    return false;
  }
 
  protected function filter($search,$params,$loose = false){
    $this->_controller->component('log')->debug(__CLASS__ . "::filter(search,params,loose)",__FILE__,__LINE__,['id' => $this->_id] + compact('search','params','loose'));
    $records = [];
    foreach($this->data($params) as $record){
      $match = true;
      foreach($search as $column => $values){
        $value = \Rsi\Record::iget($record,$column);
        foreach($values as $type => $ref){
          if(array_key_exists($column,$this->search)) $match = call_user_func($this->search[$column],$value,$ref,$record);
          else switch($type){
            case self::SEARCH_FROM:
              $match = $value >= $ref;
              break;
            case self::SEARCH_TO:
              $match = $value <= $ref;
              break;
            case self::SEARCH_EXACT:
              foreach((is_array($ref) ? $ref : [$ref]) as $ref)
                if(($ref && !($match = !strcasecmp($value,$ref))) || ((($ref === null) || ($ref == 'null')) && !($match = ($value === null)))) break;
                elseif(($ref == '""') && !($match = !strcmp($value,''))) break;
              break;
            case self::SEARCH_DATE:
              foreach((array)$ref as $date)
                if(($date = \Rsi\Fred\DateTime\Date::create($date)) && !($match = ($value >= (string)$date) && ($value < (string)$date->add()))) break;
              break;
            case self::SEARCH_LIKE:
              foreach((array)$ref as $like) if($like){
                if(!preg_match('/^\\/.+\\/$/',$like)){
                  if($like == 'null') $match = $value === null;
                  elseif($like == '""') $match = !strcmp($value,'');
                  else{
                    if($not = substr($like,0,1) == '-') $like = substr($like,1);
                    $mask = strtr(preg_quote($like,'/'),['\\?' => '.','\\*' => '.*']);
                    if($loose) $mask = "(?!$mask).+$mask";
                    $match = ($not xor preg_match("/^$mask/i",$value));
                  }
                }
                else try{
                  $match = preg_match($like . 'i',$value);
                }
                catch(\Exception $e){
                  $this->_controller->component('log')->debug("Invalid reg-ex '$like': " . str_replace('preg_match(): Compilation failed: ','',$e->getMessage()),__FILE__,__LINE__);
                  return [];
                }
                if(!$match) break;
              }
              break;
          }
          if(!$match) break;
        }
        if(!$match) continue 2;
      }
      $records[] = $record;
    }
    return $records;
  }
 
  protected function sort($records,$order){
    if(($order !== false) && ($order || $this->order)){
      if($order){
        $default = $this->order;
        foreach($order as $column => &$type) if(array_key_exists($column,$default)){
          $type |= ($default[$column] & 0xf0);
          unset($default[$column]);
        }
        unset($type);
        $order += $default;
      }
      else $order = $this->order;
      $params = [];
      foreach($order as $column => $type) $params = array_merge($params,[\Rsi\Record::column($records,$column),$type & 0xf,$type >> 4]);
      $params[] = &$records;
      call_user_func_array('array_multisort',$params);
    }
    return $records;
  }
 
  protected function _search($search,$order,$params,$offset,$limit){
    if($search){
      if(!array_key_exists($key = 'search-' . md5(serialize(compact('search','params'))),$this->_cache))
        $this->_cache[$key] = $this->filter($search,$params);
      $records = $this->sort($this->_cache[$key],$order);
      foreach($search as $values) foreach($values as $type => $ref) if($type == self::SEARCH_LIKE){
        if(!array_key_exists($key .= '-loose',$this->_cache)) $this->_cache[$key] = $this->filter($search,$params,true);
        $records = array_merge($records,$this->sort($this->_cache[$key],$order));
        break 2;
      }
    }
    else $records = $this->sort($this->data($params),$order);
    return $limit ? array_slice($records,$offset,$limit) : $records;
  }
 
  protected function _totals($search,$totals,$params){
    $results = $counts = $averages = [];
 
    foreach($totals as $column => &$types){
      $results[$column] = $counts[$column] = [];
      foreach(($types = is_array($types) ? $types : [$types]) as $type)
        $results[$column][$type] = $counts[$column][$type] = null;
    }
    unset($types);
 
    foreach(($records = $this->_search($search,false,$params,null,null)) as $record){
      foreach($totals as $column => $types) foreach($types as $type){
        $result = \Rsi\Record::iget($record,$column);
        switch($type){
          case Controller::TOTAL_COUNT:
            $results[$column][$type]++;
            break;
          case Controller::TOTAL_STD:
            if(!array_key_exists($column,$averages)) $averages[$column] = \Rsi\Record::average(array_column($records,$column));
            $result = pow($result - $averages[$column],2);
          case Controller::TOTAL_AVG:
            $counts[$column][$type]++;
          case Controller::TOTAL_SUM:
            $results[$column][$type] += $result;
            break;
          case Controller::TOTAL_MAX:
            if(($result !== null) && (($results[$column][$type] === null) || ($result > $results[$column][$type])))
              $results[$column][$type] = $result;
            break;
          case Controller::TOTAL_MIN:
            if(($result !== null) && (($results[$column][$type] === null) || ($result < $results[$column][$type])))
              $results[$column][$type] = $result;
            break;
          case Controller::TOTAL_UNIQUE:
            if(!$results[$column][$type]) $results[$column][$type] = [];
            if(!in_array($result,$results[$column][$type])) $results[$column][$type][] = $result;
            break;
          case Controller::TOTAL_NULL:
            if($result === null) $results[$column][$type]++;
            break;
          case Controller::TOTAL_NOT_NULL:
            if($result !== null) $results[$column][$type]++;
            break;
        }
      }
    }
 
    foreach($totals as $column => $types) foreach($types as $type){
      if(is_array($results[$column][$type])) $results[$column][$type] = count($results[$column][$type]);
      if($counts[$column][$type]) $results[$column][$type] /= $counts[$column][$type];
      if($type == Controller::TOTAL_STD) $results[$column][$type] = sqrt($results[$column][$type]);
    }
 
    return $results;
  }
 
  protected function _group($search,$group,$column,$total,$limit,$params){
    $result = [];
    foreach(array_unique(\Rsi\Record::column($this->_search($search,false,$params,null,null),$group)) as $value)
      $result[$value] = \Rsi\Record::get($this->_totals([$group => [self::SEARCH_EXACT => $value]] + $search,[$column => [$total]],$params),[$column,$total]);
    if(!$limit) return \Rsi\Record::sort($result,SORT_FLAG_CASE,true);
    $result = \Rsi\Record::sort($result,SORT_FLAG_CASE);
    return $limit > 0 ? array_slice($result,0,$limit) : array_reverse(array_slice($result,$limit));
  }
 
}