src-empire/Empire/Core/AbstractEntity.php line 25

Open in your IDE?
  1. <?php
  2. namespace Empire\Core;
  3. use Doctrine\DBAL\Connection;
  4. use Doctrine\DBAL\DBALException;
  5. use Doctrine\DBAL\FetchMode;
  6. abstract class AbstractEntity implements Entity {
  7.     public static $CACHE;
  8.     public $id;
  9.     public $type;
  10.     public function __construct($initialize false) {
  11.         if($initialize)
  12.             $this->initialize();
  13.     }
  14.     /**
  15.      * @param int[] $ids
  16.      * @param bool $forceArray
  17.      * @param bool $cache
  18.      * @return static[]|static
  19.      */
  20.     static function load(array $ids$forceArray=false$cache true) {
  21.         if(count($ids) < 1) {
  22.             return $forceArray ? [] : null;
  23.         }
  24.         $class get_called_class();
  25.         if($cache && count($ids) == && isset(self::$CACHE[$class][$ids[0]])) {
  26.             $res = [self::$CACHE[$class][$ids[0]]];
  27.         } else {
  28.             /** @var static $temp */
  29.             $temp = new $class;
  30.             try {
  31.                 $stmt Core::db()->executeQuery(sprintf("SELECT * FROM %s WHERE %s IN (?)"$temp->getTable(), $temp->getPrimaryField()),
  32.                     [$ids],
  33.                     [Connection::PARAM_INT_ARRAY]);
  34.             } catch (DBALException $e) {
  35.                 return $forceArray ? [] : null;
  36.             }
  37.             /** @var AbstractEntity[] $res */
  38.             $res $stmt->fetchAll(FetchMode::CUSTOM_OBJECT$class, [true]);
  39.             foreach ($res as $r$r->initialize(); // This is necessary when not using Empire\Legacy\db, because the constructor isn't always called.
  40.             if($cache && count($ids) == 1) {
  41.                 self::$CACHE[$class][$res[0]->id] = $res[0];
  42.             }
  43.         }
  44.         if(isset($res[1]) || $forceArray == true) {
  45.             return $res;
  46.         }
  47.         
  48.         return array_shift($res);
  49.     }
  50.     
  51.     function getID(){
  52.         return $this->id;
  53.     }
  54.     function uid($separator ':'){
  55.         return (int)($this->type) . $separator . (int)($this->id);
  56.     }
  57.     /**
  58.      * @param static $other
  59.      * @return bool
  60.      */
  61.     function is($other){
  62.         if(!$other){
  63.             return false;
  64.         }
  65.         return $this->uid() == $other->uid();
  66.     }
  67.     /**
  68.      * @param array $fields
  69.      * @return int|bool
  70.      * @throws DBALException
  71.      */
  72.     function updateFields(array $fields = array()) {
  73.         return Core::db()->update($this->getTable(), $fields, [$this->getPrimaryField() => $this->getID()]);
  74.     }
  75.     
  76.     function refresh() {
  77.         /** @var static $class */
  78.         $class get_called_class();
  79.         
  80.         $new $class::load([$this->getID()], falsefalse);
  81.         //delete everything from the old object
  82.         foreach($this as $key => $value){
  83.             unset($this->$key);
  84.         }
  85.         //and set it again from our new object
  86.         foreach($new as $key => $value){
  87.             $this->$key $value;
  88.         }
  89.         
  90.         return $this;
  91.     }
  92.     
  93.     /**
  94.      * Function to delete by unique ID.
  95.      * 
  96.      * Can be overwritten in the child classes to provide for more checking
  97.      * (child units, etc)
  98.      */
  99.     function delete() {
  100.         Core::db()->executeQuerysprintf("DELETE FROM %s WHERE %s = ?"$this->getTable(), $this->getPrimaryField()), [$this->getID()]);
  101.         $this->isDeleted true;
  102.         return true;
  103.     }
  104.     
  105. }