Initial commit

includes/application/code/community/Legacies/Core/Collection.php

@@ -0,0 +1,302 @@
+<?php
+
+class Legacies_Core_Collection
+    extends Legacies_Core_Model
+    implements Iterator, Countable
+{
+    protected $_tableName = null;
+    protected $_tableAlias = null;
+    protected $_entityClassName = 'Legacies_Object';
+
+    protected $_columns = array();
+    protected $_where = array();
+    protected $_join = array();
+    protected $_order = array();
+    protected $_union = array();
+    protected $_limit = null;
+    protected $_offset = null;
+    protected $_group = array();
+
+    protected $_items = array();
+
+    public function __construct($tableName = null, $entityClassName = null)
+    {
+        if ($tableName !== null) {
+            $this->setTableName($tableName);
+        }
+        if ($entityClassName != null) {
+            $this->setEntityClassName($entityClassName);
+        }
+    }
+
+    protected function _init()
+    {
+        return $this;
+    }
+
+    public function setTableName($tableName)
+    {
+        if (!is_array($tableName)) {
+            $this->_tableName = $tableName;
+        } else {
+            $this->_tableName = current($tableName);
+            $this->_tableAlias = key($tableName);
+        }
+
+        return $this;
+    }
+
+    public function getTableName()
+    {
+        return $this->_tableName;
+    }
+
+    public function setEntityClassName($entityClassName)
+    {
+        $this->_entityClassName = $entityClassName;
+
+        return $this;
+    }
+
+    public function getEntityClassName()
+    {
+        return $this->_entityClassName;
+    }
+
+    public function quote($data)
+    {
+        static $database = null;
+
+        if ($database === null) {
+            $database = Legacies_Database::getSingleton();
+        }
+
+        return $database->quote($data);
+    }
+
+    public function column($column = '*', $alias = null)
+    {
+        if (is_array($column)) {
+            foreach ($column as $alias => $field) {
+                if (is_int($alias)) {
+                    $this->_columns[] = array($field);
+                } else {
+                    $this->_columns[] = array($alias => $field);
+                }
+            }
+        } else if ($alias === null || is_int($alias)) {
+            $this->_columns[] = array($column);
+        } else {
+            $this->_columns[] = array($alias => $column);
+        }
+
+        return $this;
+    }
+
+    public function where($condition)
+    {
+        $this->_where[] = $condition;
+
+        return $this;
+    }
+
+    public function join($table, $condition, $fields = array('*'), $mode = 'INNER')
+    {
+        static $database = null;
+
+        if ($database === null) {
+            $database = Legacies_Database::getSingleton();
+        }
+
+        if (is_array($table)) {
+            $alias = key($table);
+            $table = current($table);
+
+            foreach ($fields as $fieldAlias => $fieldName) {
+                $this->column("{$alias}.{$field}", $fieldAlias);
+            }
+
+            $this->_join[] = "{$mode} JOIN {$database->getTable($table)} AS {$alias} ON {$condition}";
+        } else {
+            foreach ($fields as $field) {
+                $this->column("{$field}");
+            }
+
+            $this->_join[] = "{$mode} JOIN {$database->getTable($table)} ON {$condition}";
+        }
+
+        return $this;
+    }
+
+    public function order($field, $direction = 'ASC')
+    {
+        $this->_order[] = "{$field} {$direction}";
+
+        return $this;
+    }
+
+    public function union($collection)
+    {
+        $this->_union[] = $collection;
+
+        return $this;
+    }
+
+    public function limit($limit, $offset = null)
+    {
+        $this->_limit = intval($limit);
+        $this->_offset = $offset;
+
+        return $this;
+    }
+
+    public function group($groupField)
+    {
+        $this->_group[] = $groupField;
+
+        return $this;
+    }
+
+    public function _prepareSql()
+    {
+        if (empty($this->_union)) {
+            $database = Legacies_Database::getSingleton();
+
+            $fields = array();
+            foreach ($this->_columns as $field) {
+                $fieldName = current($field);
+                $fieldAlias = key($field);
+                if (is_string($fieldAlias)) {
+                    $fields[] = "{$fieldName} AS {$fieldAlias}";
+                } else {
+                    $fields[] = $fieldName;
+                }
+            }
+            $fields = implode(", ", $fields);
+            $where = implode(" AND ", $this->_where);
+            $joinedTables = implode("\n ", $this->_join);
+
+            $order = '';
+            if (!empty($this->_order)) {
+                $order = 'ORDER BY ' . implode(", ", $this->_order);
+            }
+            $alias = '';
+            if ($this->_tableAlias !== null) {
+                $alias = " AS {$this->_tableAlias}";
+            }
+            $limit = '';
+            if ($this->_limit) {
+                if ($this->_offset) {
+                    $limit = "LIMIT {$this->_limit}, {$this->_offset}";
+                } else {
+                    $limit = "LIMIT {$this->_limit}";
+                }
+            }
+            $group = '';
+            if (!empty($this->_group)) {
+                $group = 'GROUP BY ' . implode(', ', $this->_group);
+            }
+
+            return <<<SQL_EOF
+SELECT {$fields}
+    FROM {$database->getTable($this->getTableName())}{$alias}
+    {$joinedTables}
+    WHERE $where
+    {$group}
+    {$order}
+    {$limit}
+SQL_EOF;
+        } else {
+            $statements = array();
+            foreach ($this->_union as $statement) {
+                $statements[] = $statement->_prepareSql();
+            }
+
+            $statements = '(' . implode(') UNION (', $statements) . ')';
+            $where = implode(" AND ", $this->_where);
+
+            $limit = '';
+            if ($this->_limit) {
+                if ($this->_offset) {
+                    $limit = "LIMIT {$this->_limit}, {$this->_offset}";
+                } else {
+                    $limit = "LIMIT {$this->_limit}";
+                }
+            }
+
+            return <<<SQL_EOF
+$statements
+    WHERE $where
+    {$limit}
+SQL_EOF;
+        }
+    }
+
+    protected function _load()
+    {
+        $sql = $this->_prepareSql();
+
+        $database = Legacies_Database::getSingleton();
+        $statement = $database->prepare($sql);
+
+        $args = func_get_args();
+        $statement->execute(array_shift($args));
+
+        $this->_items = array();
+        $reflection = new ReflectionClass($this->getEntityClassName());
+        while ($row = $statement->fetch(PDO::FETCH_ASSOC)) {
+            $args = array($row) + $args;
+            $this->_items[] = $reflection->newInstanceArgs($args);
+        }
+
+        return $this;
+    }
+
+    protected function _save()
+    {
+        foreach ($this->_items as $child) {
+            $child->save();
+        }
+
+        return $this;
+    }
+
+    protected function _delete()
+    {
+        foreach ($this->_items as $child) {
+            $child->delete();
+        }
+
+        return $this;
+    }
+
+    public function count()
+    {
+        return count($this->_items);
+    }
+
+    public function current()
+    {
+        return current($this->_items);
+    }
+
+    public function next()
+    {
+        return next($this->_items);
+    }
+
+    public function rewind()
+    {
+        return reset($this->_items);
+    }
+
+    public function key()
+    {
+        return key($this->_items);
+    }
+
+    public function valid()
+    {
+        return (key($this->_items) < (current($this->_items)));
+    }
+}

includes/application/code/community/Legacies/Core/Entity.php

@@ -0,0 +1,162 @@
+<?php
+
+abstract class Legacies_Core_Entity
+    extends Legacies_Core_Model
+    implements Legacies_Core_EntityInterface
+{
+    protected $_idFieldName = null;
+    protected $_tableName = null;
+
+    public function setIdFieldName($fieldName)
+    {
+        $this->_idFieldName = $fieldName;
+
+        return $this;
+    }
+
+    public function getIdFieldName()
+    {
+        return $this->_idFieldName;
+    }
+
+    public function setTableName($tableName)
+    {
+        $this->_tableName = $tableName;
+
+        return $this;
+    }
+
+    public function getTableName()
+    {
+        return $this->_tableName;
+    }
+
+    public function setId($id)
+    {
+        $this->setData($this->getIdFieldName(), $id);
+
+        return $this;
+    }
+
+    public function getId()
+    {
+        return $this->getData($this->getIdFieldName());
+    }
+
+    protected function _load()
+    {
+        static $statement = null;
+
+        $id = func_get_arg(0);
+
+        if ($statement === null) {
+            $idFieldName = self::getIdFieldName();
+            $database = Legacies_Database::getSingleton();
+
+            $sql =<<<SQL_EOF
+SELECT * FROM {$database->getTable(self::getTableName())}
+    WHERE {$idFieldName}=:id
+    LIMIT 1
+SQL_EOF;
+            $statement = $database->prepare($sql);
+        }
+
+        $statement->execute(array(
+            'id' => $id
+            ));
+
+        $datas = $statement->fetch(PDO::FETCH_ASSOC);
+        if (!is_array($datas) || empty($datas)) {
+            throw new Legacies_Core_Model_Exception('Could not load data: this id could not be found.');
+        }
+        unset($datas[self::getIdFieldName()]);
+
+        $this->_data = $datas;
+        $this->setId($id);
+
+        return $this;
+    }
+
+    protected function _save()
+    {
+        if ($this->getId() !== null) {
+            $fields = array();
+            $values = array();
+            foreach ($this->getAllDatas() as $field => $value) {
+                if ($field == self::getIdFieldName()) {
+                    continue;
+                }
+                $fields[] = "{$field}=:{$field}";
+                $values[$field] = $value;
+            }
+
+            $fieldsImploded = implode(', ', $fields);
+            $idFieldName = self::getIdFieldName();
+            $values[$idFieldName] = $this->getId();
+
+            $database = Legacies_Database::getSingleton();
+            $sql =<<<SQL_EOF
+UPDATE {$database->getTable(self::getTableName())}
+    SET {$fieldsImploded}
+    WHERE {$idFieldName}=:{$idFieldName}
+SQL_EOF;
+            $statement = $database->prepare($sql);
+
+            $statement->execute($values);
+        } else {
+            $datas = $this->getAllDatas();
+            $fieldsImploded = implode(', ', array_keys($datas));
+
+            $tokens = array();
+            $values = array();
+            foreach ($datas as $field => $value) {
+                if ($field == self::getIdFieldName()) {
+                    continue;
+                }
+                $tokens[] = ":{$field}";
+                $values[$field] = $value;
+            }
+            $tokensImploded = implode(', ', $tokens);
+
+            $database = Legacies_Database::getSingleton();
+            $sql =<<<SQL_EOF
+INSERT INTO {$database->getTable(self::getTableName())} ($fieldsImploded)
+    VALUES ({$tokensImploded})
+SQL_EOF;
+            $statement = $database->prepare($sql);
+
+            $statement->execute($values);
+
+            $this->setId($database->lastInsertId());
+        }
+
+        return $this;
+    }
+
+    protected function _delete()
+    {
+        static $statement = null;
+
+        if ($statement == null) {
+            $fields = array();
+            foreach ($this->getAllDatas() as $field => $value) {
+                if ($field == self::getIdFieldName()) {
+                    continue;
+                }
+                $fields[] = "{$field}=:{$field}";
+            }
+
+            $fieldsImploded = implod(', ', $fields);
+            $idFieldName = self::getIdFieldName();
+            $database = Legacies_Database::getSingleton();
+            $sql =<<<SQL_EOF
+DELETE {$database->getTable(self::getTableName())}
+    WHERE {$idFieldName}=:{$idFieldName}
+SQL_EOF;
+        }
+
+        $statement->execute($this->getAllDatas());
+
+        return $this;
+    }
+}

includes/application/code/community/Legacies/Core/EntityInterface.php

@@ -0,0 +1,13 @@
+<?php
+
+interface Legacies_Core_EntityInterface
+{
+    public function getId();
+    public function setId($id);
+
+    public function getIdFieldName();
+    public function setIdFieldName($fieldName);
+
+    public function getTableName();
+    public function setTableName($tableName);
+}

includes/application/code/community/Legacies/Core/Exception.php

@@ -0,0 +1,3 @@
+<?php
+
+interface Legacies_Core_Exception extends Legacies_Exception {}

includes/application/code/community/Legacies/Core/Model.php

@@ -0,0 +1,100 @@
+<?php
+
+abstract class Legacies_Core_Model
+    extends Legacies_Object
+{
+    protected $_originalData = array();
+    protected $_data = array();
+
+    public function __construct(Array $data = array())
+    {
+        $this->_data = $data;
+        $this->_setOriginalData($data);
+
+        $this->_init();
+    }
+
+    abstract protected function _init();
+
+    protected function _setOriginalData(Array $data)
+    {
+        $this->_originalData = $data;
+    }
+
+    final public function save()
+    {
+        try {
+            $params = func_get_args();
+            call_user_func_array(array($this, '_beforeSave'), $params);
+            call_user_func_array(array($this, '_save'), $params);
+            call_user_func_array(array($this, '_afterSave'), $params);
+            $this->_setOriginalData($this->_data);
+        } catch (PDOException $e) {
+            throw new Legacies_Core_Model_Exception('Could not save data: ' . $e->getMessage(), 0);
+        }
+        return $this;
+    }
+
+    abstract protected function _save();
+
+    protected function _beforeSave()
+    {
+        return $this;
+    }
+
+    protected function _afterSave()
+    {
+        return $this;
+    }
+
+    final public function load()
+    {
+        try {
+            $params = func_get_args();
+            call_user_func_array(array($this, '_beforeLoad'), $params);
+            call_user_func_array(array($this, '_load'), $params);
+            call_user_func_array(array($this, '_afterLoad'), $params);
+            $this->_setOriginalData($this->_data);
+        } catch (PDOException $e) {
+            throw new Legacies_Core_Model_Exception('Could not load data: ' . $e->getMessage(), 0);
+        }
+        return $this;
+    }
+
+    abstract protected function _load();
+
+    protected function _beforeLoad()
+    {
+        return $this;
+    }
+
+    protected function _afterLoad()
+    {
+        return $this;
+    }
+
+    final public function delete()
+    {
+        try {
+            $params = func_get_args();
+            call_user_func_array(array($this, '_beforeDelete'), $params);
+            call_user_func_array(array($this, '_delete'), $params);
+            call_user_func_array(array($this, '_afterDelete'), $params);
+        } catch (PDOException $e) {
+            throw new Legacies_Core_Model_Exception('Could not delete entity: ' . $e->getMessage(), 0);
+        }
+        return $this;
+    }
+
+    abstract protected function _delete();
+
+    protected function _beforeDelete()
+    {
+        return $this;
+    }
+
+    protected function _afterDelete()
+    {
+        return $this;
+    }
+}

includes/application/code/community/Legacies/Core/Model/Config.php

@@ -0,0 +1,85 @@
+<?php
+
+/**
+ *
+ * Enter description here ...
+ *
+ * @uses Legacies_Object
+ * @uses Legacies_Empire
+ */
+class Legacies_Core_Model_Config
+    extends Legacies_Core_Model
+    implements Legacies_Core_Singleton
+{
+    private static $_singleton = null;
+
+    public static function getSingleton()
+    {
+        if (self::$_singleton === null) {
+            self::$_singleton = new self();
+        }
+        return self::$_singleton;
+    }
+
+    protected function _init()
+    {
+        $this->load();
+    }
+
+    protected function _load()
+    {
+        $database = Legacies_Database::getSingleton();
+
+        $sql =<<<SQL_EOF
+SELECT config_name AS attribute, config_value AS value
+  FROM {$database->getTable('config')} AS config
+SQL_EOF;
+
+        $attributeName = null;
+        $attributeValue = null;
+
+        $statement = $database->prepare($sql);
+        $statement->execute();
+
+        $statement->bindColumn('attribute', $attributeName, PDO::PARAM_STR);
+        $statement->bindColumn('value', $attributeValue, PDO::PARAM_STR);
+
+        while ($statement->fetch(PDO::FETCH_BOUND)) {
+            $this->setData($attributeName, $attributeValue);
+        }
+        return $this;
+    }
+
+    protected function _save()
+    {
+        $database = Legacies_Database::getSingleton();
+        $fields = array();
+
+        $sql =<<<SQL_EOF
+UPDATE {{table}}
+  SET config_value=:value
+  WHERE config_name=:name
+SQL_EOF;
+        $statement = $database->prepare($sql);
+
+        foreach ($this->getAllDatas() as $attributeName => $attributeValue) {
+            $statement->execute(array(
+                'name'  => $attributeName,
+                'value' => $attributeValue
+                ));
+        }
+
+        return $this;
+    }
+
+    protected function _delete()
+    {
+        // NOP
+        return $this;
+    }
+
+    public function isEnabled()
+    {
+        return (bool) $this->getData('game_disable');
+    }
+}

includes/application/code/community/Legacies/Core/Model/Exception.php

@@ -0,0 +1,7 @@
+<?php
+
+class Legacies_Core_Model_Exception
+    extends RuntimeException
+    implements Legacies_Core_Exception
+{
+}

includes/application/code/community/Legacies/Core/Model/Session.php

@@ -0,0 +1,116 @@
+<?php
+
+/**
+ *
+ * Enter description here ...
+ *
+ * @uses Legacies_Object
+ * @uses Legacies_Empire
+ */
+class Legacies_Core_Model_Session
+    extends Legacies_Object
+{
+    const CRIT  = 0x80;
+    const ERROR = 0x40;
+    const WARN  = 0x20;
+    const INFO  = 0x10;
+    const DEBUG = 0x01;
+
+    protected static $_instances = null;
+
+    protected static $_levels = null;
+
+    public static function factory($namespace)
+    {
+        $namespace = (string) $namespace;
+        if (!isset(self::$_instances[$namespace])) {
+            if (self::$_levels === null) {
+                $reflection = new ReflectionClass(__CLASS__);
+                self::$_levels = array_flip($reflection->getConstants());
+            }
+            if (session_id() == '') {
+                session_start();
+            }
+
+            self::$_instances[$namespace] = new self($namespace);
+        }
+        return self::$_instances[$namespace];
+    }
+
+    public static function destroy()
+    {
+        session_destroy();
+    }
+
+    public function __construct($namespace)
+    {
+        $this->_data = &$_SESSION[$namespace];
+        $this->_data['messages'] = array();
+    }
+
+    public function getMessages($clear = true)
+    {
+        $messages = $this->_data['messages'];
+        if ($clear == true) {
+            $this->_data['messages'] = array();
+        }
+        return $messages;
+    }
+
+    public function addMessage($message, $type = self::DEBUG)
+    {
+        if (!isset(self::$_levels[$type])) {
+            $type = self::DEBUG;
+        }
+
+        if (!isset($this->_data['messages'])) {
+            $this->_data['messages'] = array();
+        }
+        if (!isset($this->_data['messages'][self::$_levels[$type]])) {
+            $this->_data['messages'][self::$_levels[$type]] = array();
+        }
+        $this->_data['messages'][self::$_levels[$type]][] = $message;
+
+        return $this;
+    }
+
+    public function addCritical($message, $_ = null)
+    {
+        $args = func_get_args();
+        array_shift($args);
+
+        return $this->addMessage(vsprintf($message, $args), self::CRIT);
+    }
+
+    public function addError($message, $_ = null)
+    {
+        $args = func_get_args();
+        array_shift($args);
+
+        return $this->addMessage(vsprintf($message, $args), self::ERROR);
+    }
+
+    public function addWarning($message, $_ = null)
+    {
+        $args = func_get_args();
+        array_shift($args);
+
+        return $this->addMessage(vsprintf($message, $args), self::WARN);
+    }
+
+    public function addInfo($message, $_ = null)
+    {
+        $args = func_get_args();
+        array_shift($args);
+
+        return $this->addMessage(vsprintf($message, $args), self::INFO);
+    }
+
+    public function addDebug($message, $_ = null)
+    {
+        $args = func_get_args();
+        array_shift($args);
+
+        return $this->addMessage(vsprintf($message, $args), self::DEBUG);
+    }
+}

includes/application/code/community/Legacies/Core/Model/Translator.php

@@ -0,0 +1,37 @@
+<?php
+
+class Legacies_Core_Model_Translator
+{
+    protected $_translations = array();
+
+    public function __construct($path, $locale)
+    {
+        $fileList = glob($path . DIRECTORY_SEPARATOR . $locale . DIRECTORY_SEPARATOR . '*.csv');
+        foreach ($fileList as $file) {
+            $fp = fopen($file, 'r');
+            while (!feof($fp)) {
+                $line = fgetcsv($fp);
+                if (count($line) >= 2) {
+                    $this->_translations[$line[0]] = $line[1];
+                }
+            }
+        }
+    }
+
+    public function translate($message, $_ = null)
+    {
+        $args = func_get_args();
+        array_shift($args);
+
+        return $this->translateArgs($message, $args);
+    }
+
+    public function translateArgs($message, Array $args = array())
+    {
+        if (isset($this->_translations[$message])) {
+            $message = $this->_translations[$message];
+        }
+
+        return vsprintf($message, $args);
+    }
+}

includes/application/code/community/Legacies/Core/Singleton.php

@@ -0,0 +1,6 @@
+<?php
+
+interface Legacies_Core_Singleton
+{
+    public static function getSingleton();
+}

includes/application/code/community/Legacies/Core/View.php

@@ -0,0 +1,70 @@
+<?php
+
+class Legacies_Core_View
+    extends Legacies_Object
+{
+    protected $_template = null;
+
+    public function __construct(Array $data = array())
+    {
+        parent::__construct($data);
+    }
+
+    protected function _prepareRender()
+    {
+        return $this;
+    }
+
+    public function renderNumber($number)
+    {
+        return Math::render($number);
+    }
+
+    protected function escape($unescaped)
+    {
+        return htmlspecialchars($unescaped, ENT_QUOTES, 'UTF-8');
+    }
+
+    public function __($message, $_ = null)
+    {
+        $args = func_get_args();
+        array_shift($args);
+
+        return Legacies::translateArgs($message, $args);
+    }
+
+    public function renderScript($file)
+    {
+        $this->_prepareRender();
+
+        $path = APPLICATION_PATH . DIRECTORY_SEPARATOR . 'design' . DIRECTORY_SEPARATOR . 'scripts';
+
+        ob_start();
+        include $path . DIRECTORY_SEPARATOR . $file;
+        $contents = ob_get_contents();
+        ob_end_clean();
+
+        return $contents;
+    }
+
+    public function render()
+    {
+        $template = $this->getTemplate();
+        if (empty($template)) {
+            return null;
+        }
+        return $this->renderScript($this->getTemplate());
+    }
+
+    public function setTemplate($template)
+    {
+        $this->_template = $template;
+
+        return $this;
+    }
+
+    public function getTemplate()
+    {
+        return $this->_template;
+    }
+}