webadmin.php

/var/www/(Del)pathways.org.hk/MIS_bk/inc/configure.php

<?php
//-----------------------------------------------------------------------------
// Define
//-----------------------------------------------------------------------------
define('PROJECT_FOLDER', 'MIS');
define('PROJECT_PATH', '/MIS/');
define('PROJECT_ROOT', $_SERVER['DOCUMENT_ROOT'] . PROJECT_PATH);

//-----------------------------------------------------------------------------
// Error reporting level
//-----------------------------------------------------------------------------
//TODO: Production should comment the next line
error_reporting(E_ALL ^ E_NOTICE);

//-----------------------------------------------------------------------------
// Timezone
//-----------------------------------------------------------------------------
date_default_timezone_set('Asia/Hong_Kong');
//date_default_timezone_set('HKT/8.0/no DST');

//-----------------------------------------------------------------------------
// Underscore
//-----------------------------------------------------------------------------
require_once(__DIR__ . '/underscore.php');

//-----------------------------------------------------------------------------
// Session
//-----------------------------------------------------------------------------
if ($without_session_start !== true) {
    session_start();
}

//-----------------------------------------------------------------------------
// Send default header
//-----------------------------------------------------------------------------
if ($without_send_header !== true) {
    // IE use last version
    if ($without_use_last_ie_version !== true) {
        header('X-UA-Compatible: IE=edge,chrome=1');
    }
    // Powered by
    if ($without_x_powered_by !== true) {
        header('X-Powered-By: OneSolution');
    }
    // No cache
    if ($without_no_cache_header !== true) {
        // Expires in the past
        header('Expires: Mon, 26 Jul 1990 05:00:00 GMT');
        // Always modified
        header('Last-Modified: ' . gmdate("D, d M Y H:i:s") . ' GMT'); 
        // HTTP/1.1 
        header('Cache-Control: no-store, no-cache, must-revalidate'); 
        header('Cache-control: private', false); // IE 6 FIX
        header('Cache-Control: post-check=0, pre-check=0', false); 
        // HTTP/1.0 
        header('Pragma: no-cache');
    }
}

//-----------------------------------------------------------------------------
// Connections
//-----------------------------------------------------------------------------
require_once(__DIR__ . '/db.php');
if ($without_connection !== true) {
    $PDO_OPTIONS = array(
        PDO::ATTR_CASE => PDO::CASE_LOWER,
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_ORACLE_NULLS => PDO::NULL_NATURAL,
        PDO::ATTR_STRINGIFY_FETCHES => false,
    );

    //-----------------------------------------------------------------------------
    // MySQL
    //-----------------------------------------------------------------------------
    // development
//    $dbh = new PDO("mysql:host=127.0.0.1;dbname=pathwaysmisdb", 'pathwayssa', 'df3S8230', $PDO_OPTIONS);
    // production
    $dbh = new PDO("mysql:host=192.168.171.21;dbname=pathwaysmisdb", 'pathwayssa', 'df3S8230', $PDO_OPTIONS);
    $sql = "SET NAMES ?";
    $parameters = array('utf8');
    $sth = Db\Util::execute($dbh, $sql, $parameters);

    //-----------------------------------------------------------------------------
    // SQL Server
    //-----------------------------------------------------------------------------
//    $sqlsrv_dbh = new PDO("sqlsrv:Server=127.0.0.1;Database=DB", 'sa', 'password', $PDO_OPTIONS);
}

//-----------------------------------------------------------------------------
// Global functions
//-----------------------------------------------------------------------------
function redirectAndExit($url) {
    header('Location: ' . $url);
    exit;
}

function isPost() {
    return strtoupper($_SERVER['REQUEST_METHOD']) == 'POST';
}

function isGet() {
    return strtoupper($_SERVER['REQUEST_METHOD']) == 'GET';
}

/**
 * Wrapper of htmlspecialchars()
 * @param string $text
 * @param string $charset
 * @return string
 */
function h($text, $charset = null) {
//    return htmlspecialchars($text, ENT_QUOTES | ENT_HTML401, isset($charset) ? $charset : 'UTF-8');
    return htmlspecialchars($text, ENT_QUOTES, isset($charset) ? $charset : 'UTF-8');
}

/**
 * Helper class - Util
 */
class Util {
    
    public static function isAdmin() {
        $roles = array(
            1, // SuperAdmin
            2, // Admin
        );
        return in_array($_SESSION['webadmin']['role'], $roles);
    }
    
    public static function getSortDirection(array &$sort, $column) {
        foreach ($sort as $index => $info) {
            if (!empty($info['column']) && !empty($info['option']) && $info['column'] == $column) {
                return $info['option'];
            }
        }
        return null;
    }
    
    public static function getSortDirectionCaretHtml(array &$sort, $column) {
        $direction = static::getSortDirection($sort, $column);
        if (isset($direction)) {
            switch (strtoupper($direction)) {
                case 'ASC': {
                    return '<span class="dropdown"><i class="caret"></i></span>';
                }
                case 'DESC': {
                    return '<span class="dropdown dropup"><i class="caret"></i></span>';
                }
            }
        }
        return '';
    }
    
    public static function date_to_string(DateTime $datetime, $format = 'Y-m-d') {
        return $datetime->format($format);
    }
    
    public static function time_to_string(DateTime $datetime, $format = 'H:i:s') {
        return $datetime->format($format);
    }
    
    public static function value_to_date_string($value, $format = 'Y-m-d') {
        $output = '';
        if (!empty($value)) {
            $date = DateTime::createFromFormat('Y-m-d', $value);
            $output = $date->format($format);
        }
        return $output;
    }
    
    public static function value_to_time_string($value, $format = 'H:i') {
        $output = '';
        if (!empty($value)) {
            $date = DateTime::createFromFormat('H:i:s', $value);
            $output = $date->format($format);
        }
        return $output;
    }
    
    // Calculate the age from a given birth date
    // Example: getAge("1986-06-18");
    public static function getAge($birthdate)
    {
        $yearDiff = NULL;
        if ($birthdate != NULL) {
            // Explode the date into meaningful variables
            list($birthYear,$birthMonth,$birthDay) = explode("-", $birthdate);
            // Find the differences
            $yearDiff = date("Y") - $birthYear;
            $monthDiff = date("m") - $birthMonth;
            $dayDiff = date("d") - $birthDay;
            // If the birthday has not occured this year
            if ($dayDiff < 0 || $monthDiff < 0) {
                $yearDiff--;
            }
        }
        return $yearDiff;
    }
    
    /**
     * This will give
     * 
     * $a="/home/a.php";
     * $b="/home/root/b/b.php";
     * echo getRelativePath($a,$b), PHP_EOL;  // ./root/b/b.php
     * and
     * 
     * $a="/home/apache/a/a.php";
     * $b="/home/root/b/b.php";
     * echo getRelativePath($a,$b), PHP_EOL; // ../../root/b/b.php
     * and
     * 
     * $a="/home/root/a/a.php";
     * $b="/home/apache/htdocs/b/en/b.php";
     * echo getRelativePath($a,$b), PHP_EOL; // ../../apache/htdocs/b/en/b.php
     * and
     * 
     * $a="/home/apache/htdocs/b/en/b.php";
     * $b="/home/root/a/a.php";
     * echo getRelativePath($a,$b), PHP_EOL; // ../../../../root/a/a.php
     * 
     * @param type $from
     * @param type $to
     * @return type
     */
    public static function getRelativePath($from, $to) {
        $from = explode('/', $from);
        $to = explode('/', $to);
        $relPath = $to;

        foreach ($from as $depth => $dir) {
            // find first non-matching dir
            if ($dir === $to[$depth]) {
                // ignore this directory
                array_shift($relPath);
            } else {
                // get number of remaining dirs to $from
                $remaining = count($from) - $depth;
                if ($remaining > 1) {
                    // add traversals up to first matching dir
                    $padLength = (count($relPath) + $remaining - 1) * -1;
                    $relPath = array_pad($relPath, $padLength, '..');
                    break;
                } else {
                    $relPath[0] = './' . $relPath[0];
                }
            }
        }
        return implode('/', $relPath);
    }

    public static function link($filepath) {
        $from = $_SERVER['SCRIPT_FILENAME'];
        $to = realpath($filepath);
        
        $from = str_replace('\\', '/', $from);
        $to = str_replace('\\', '/', $to);
        
        $link = $from == $to ? '' : Util::getRelativePath($from, $to);
        if (empty($link) && $from == $to) {
            $parts = explode('/', $from);
            $count = count($parts);
            $link = $parts[$count - 1];
        }
        
        return $link;
    }
    
}

class UploadedFiles extends ArrayObject
{
    public function current() {
        return $this->_normalize(parent::current());
    }

    public function offsetGet($offset) {
        return $this->_normalize(parent::offsetGet($offset));
    }

    protected function _normalize($entry) {
        if(isset($entry['name']) && is_array($entry['name'])) {
            $files = array();
            foreach($entry['name'] as $k => $name) {
                $files[$k] = array(
                    'name' => $name,
                    'tmp_name' => $entry['tmp_name'][$k],
                    'size' => $entry['size'][$k],
                    'type' => $entry['type'][$k],
                    'error' => $entry['error'][$k]
                );
            }
            return new self($files);
        }
        return $entry;
    }

    public static function codeToMessage($code) {
        switch ($code) {
            case UPLOAD_ERR_INI_SIZE:
                $message = "The uploaded file exceeds the upload_max_filesize directive in php.ini";
                break;
            case UPLOAD_ERR_FORM_SIZE:
                $message = "The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form";
                break;
            case UPLOAD_ERR_PARTIAL:
                $message = "The uploaded file was only partially uploaded";
                break;
            case UPLOAD_ERR_NO_FILE:
                $message = "No file was uploaded";
                break;
            case UPLOAD_ERR_NO_TMP_DIR:
                $message = "Missing a temporary folder";
                break;
            case UPLOAD_ERR_CANT_WRITE:
                $message = "Failed to write file to disk";
                break;
            case UPLOAD_ERR_EXTENSION:
                $message = "File upload stopped by extension";
                break;

            default:
                $message = "Unknown upload error";
                break;
        }
        return $message;
    }
}

//-----------------------------------------------------------------------------
// Pagination
//-----------------------------------------------------------------------------
abstract class Pagination {
    
    private $number_per_page = 10;
    private $show_near_pages = 6;
    
    public function setNumberPerPage($number_per_page) {
        $this->number_per_page = $number_per_page;
    }
    
    public function getNumberPerPage() {
        return $this->number_per_page;
    }
    
    abstract protected function count();
    
    public function getOffset() {
        return ($this->getCurrentPage() - 1) * $this->number_per_page;
    }
    
    public function getLimit() {
        return $this->number_per_page;
    }
    
    public function getCurrentPage() {
        return max(intval($_GET['page']), 1);
    }
    
    private function getQueryString($cleanPage = true) {
        $get = $_GET;
        unset($get['page']);
        return $get;
    }

    protected function getPrevLink() {
        $page = $this->getCurrentPage() - 1;
        return $this->getPageLink($page);
    }

    protected function getNextLink() {
        $page = $this->getCurrentPage() + 1;
        return $this->getPageLink($page);
    }

    protected function getPageLink($page) {
        $get = $this->getQueryString();
        $get['page'] = max($page, 1);
        return '?' . http_build_query($get);
    }
    
    public function pageCount() {
        $count = $this->count();
        $page = $count / floatval($this->number_per_page);
        if (floor($page) < $page) {
            $page = floor($page) + 1;
        }
        return $page;
    }
    
    private $_cache_to_string;
    public function toString() {
        if (!empty($this->_cache_to_string)) {
            return $this->_cache_to_string;
        }
        
        $pageCount = $this->pageCount();
        $currentPage = $this->getCurrentPage();
        ob_start();
?>
<div class="pagination">
    <ul>
        <li<?=$currentPage == 1 ? ' class="disabled"' : ''?>><a href="<?=$this->getPrevLink()?>">&laquo;</a></li>
        <?php
        $is_dot = false;
        for ($i = 1; $i <= max($pageCount, 1); $i++):
            $is_show = $i == 1 || $i == $pageCount || abs($currentPage - $i) < $this->show_near_pages;
            if ($is_show):
                $is_dot = true;
        ?>
        <li<?=$currentPage == $i ? ' class="active"' : ''?>><a href="<?=$this->getPageLink($i)?>"><?=$i?></a></li>
        <?php
            elseif ($is_dot):
                $is_dot = false;
        ?>
        <li class="disabled"><a href="javascript:void(0)">...</a></li>
        <?php
            endif;
        endfor;
        ?>
        <li<?=$currentPage >= $pageCount ? ' class="disabled"' : ''?>><a href="<?=$this->getNextLink()?>">&raquo;</a></li>
    </ul>
</div>
<?php
        $this->_cache_to_string = ob_get_contents();
        ob_end_clean();
        
        return $this->_cache_to_string;
    }
    
}

class MySqlPagination extends Pagination {
    private $sql;
    private $parameters;
    private $dbh;
    
    function __construct($sql, $parameters) {
        global $dbh;
        
        $this->sql = $sql;
        $this->parameters = $parameters;
        $this->dbh = $dbh;
    }

    protected function count() {
        $sql = $this->sql;
        $sql = "SELECT COUNT(*) AS count FROM ( $sql ) t";
        if (!($sth = $this->dbh->prepare($sql))) {
            throw new Exception("sql prepare statement failure: $sql");
        }
        $sth->setFetchMode(PDO::FETCH_ASSOC);
        if (!$sth->execute($this->parameters)) {
            throw new Exception("sql execute statement failure: $sql");
        }
        $record = $sth->fetch(PDO::FETCH_ASSOC);
        
        return $record['count'];
    }
    
    public function getSqlLimitAndOffset() {
        $limit = $this->getLimit();
        $offset = $this->getOffset();
        return " LIMIT $limit OFFSET $offset ";
    }
}

class SqlsrvPagination extends Pagination {
    private $sql;
    private $parameters;
    private $dbh;
    
    function __construct($sql, $parameters) {
        global $sqlsrv_dbh;
        
        $this->sql = $sql;
        $this->parameters = $parameters;
        $this->dbh = $sqlsrv_dbh;
    }

    protected function count() {
        $sql = $this->sql;
        $pos = strpos($sql, "ORDER BY");
        if ($pos !== false) {
            $sql = substr($sql, 0, $pos);
        }
        $sql = "SELECT COUNT(*) AS count FROM ( $sql ) t";
        if (!($sth = $this->dbh->prepare($sql))) {
            throw new Exception("sql prepare statement failure: $sql");
        }
        $sth->setFetchMode(PDO::FETCH_ASSOC);
        if (!$sth->execute($this->parameters)) {
            throw new Exception("sql execute statement failure: $sql");
        }
        $record = $sth->fetch(PDO::FETCH_ASSOC);
        
        return $record['count'];
    }
    
    public function getSql() {
        $sql = $this->sql;
        $limit = $this->getLimit();
        $offset = $this->getOffset();
        
        $limit = intval($limit);
        $offset = intval($offset);

        if ($offset == 0)
            return preg_replace('/^SELECT\s/i', 'SELECT TOP ' . $limit . ' ', $sql);

        $orderby = stristr($sql, 'ORDER BY');
        $over = $orderby ? preg_replace('/\"[^,]*\".\"([^,]*)\"/i', '"inner_tbl"."$1"', $orderby) : 'ORDER BY (SELECT 0)';

        // Remove ORDER BY clause from $sql
        $sql = preg_replace('/\s+ORDER BY(.*)/', '', $sql);

        // Add ORDER BY clause as an argument for ROW_NUMBER()
        $sql = "SELECT ROW_NUMBER() OVER ($over) AS \"AR_ROWNUM\", * FROM ($sql) AS inner_tbl";

        $start = $offset + 1;
        $end = $offset + $limit;
        return "WITH outer_tbl AS ($sql) SELECT * FROM outer_tbl WHERE \"AR_ROWNUM\" BETWEEN $start AND $end";
    }
}

//-----------------------------------------------------------------------------
// Sign in
//-----------------------------------------------------------------------------
class SigninController {
    
    public function isLogin() {
        return isset($_SESSION['webadmin']['id']) && strlen($_SESSION['webadmin']['id']);
    }
    
    protected function redirectMain() {
        redirectAndExit(Util::link(__DIR__ . '/../main.php') . '?' . http_build_query($_GET));
    }
    
    protected function redirectLogin() {
        redirectAndExit(Util::link(__DIR__ . '/../login.php') . '?' . http_build_query($_GET));
    }
    
    public function checkLogin() {
        if (!$this->isLogin()) {
            $this->redirectLogin();
        }
    }
    
    public function login() {
        global $dbh;
        
        if ($this->isLogin()) {
            $this->redirectMain();
        }
        
        $message = null;
        if (!empty($_GET['message'])) {
            $message = $_GET['message'];
        }
        $message_heading = 'Error!';
        if (!empty($_GET['message_heading'])) {
            $message_heading = $_GET['message_heading'];
        }
        $message_css_class = 'alert-error';
        if (!empty($_GET['message_css_class'])) {
            $message_css_class = $_GET['message_css_class'];
        }
        
        if (isPost()) {
            $name = $_POST['name'];
            $password = $_POST['password'];
            $sql = "SELECT * FROM sys_login WHERE loginname = ? AND loginpw = ? AND actived = ? AND deleted = ?";
            $parameters = array($name, md5($password), 1, 0);
            $sth = Db\Util::execute($dbh, $sql, $parameters);
            $staff = $sth->fetch(PDO::FETCH_ASSOC);
            if (!empty($staff)) {
                // Assign webadmin session
                $_SESSION['webadmin'] = $staff;

                // Redirect to job
                $this->redirectMain();
            }
            $message = 'User name or password not correct.';
            $message_heading = 'Error!';
            $message_css_class = 'alert-error';
        }
        
        return array(
            'message' => $message,
            'message_heading' => $message_heading,
            'message_css_class' => $message_css_class,
        );
    }
    
    public function logout() {
        // Clear webadmin session
        unset($_SESSION['webadmin']);
        
        // Redirect to login
        $this->redirectLogin();
    }
    
}

//-----------------------------------------------------------------------------
// Static values
//-----------------------------------------------------------------------------
class General {
    public static function fields() {
        return array(
            'id', 'createby', 'createdate', 'lastupby', 'lastupdate',
        );
    }
    
    public static function genderOptions() {
        return array(
            1 => 'Male',
            2 => 'Female',
        );
    }
}

class User {
    public static function roleOptions() {
        return array(
            1 => 'SuperAdmin',
            2 => 'Admin',
            3 => 'Staff',
        );
    }
}

class Staff {
    public static function statusOptions() {
        return array(
            1 => 'Current',
            2 => 'Disable',
        );
    }
    
    public static function workingModeOptions() {
        return array(
            1 => 'Full Time',
            2 => 'Part Time',
        );
    }
    
    public static function attendanceLeaveOptions() {
        return array(
            1 => 'Teacher Sick Leave',
            2 => 'Annual Leave',
            3 => 'Casual Leave',
            4 => 'Students absent',
            5 => 'No pay Lesson',
        );
    }
}

class Student {
    public static function statusOptions() {
        return array(
            1 => 'Active',
            2 => 'Disable',
        );
    }
    
    public static function attendanceLeaveOptions() {
        return array(
            1 => 'Personal Leave',
            2 => 'Student Sick Leave',
            3 => 'School Event Leave',
            4 => 'Makeup class',
        );
    }
}

class Event {
    public static function programmeFeeTypeOptions() {
        return array(
            1 => 'Hourly',
            2 => 'Package',
        );
    }
    
    public static function schoolTypeOptions() {
        return array(
            1 => 'In-school',
            2 => 'Outside school',
        );
    }
}

class Lesson {
    public static function typeOptions() {
        return array(
            1 => 'Learning',
            2 => 'Counseling',
            3 => 'Consultation',
            4 => 'Meeting',
            5 => 'Pre-assessment',
            6 => 'Post-assessment',
        );
    }
}

class Subsidy {
    public static function typeOptions() {
        return array(
            1 => 'None',
            2 => 'Low income family',
            3 => 'Family with government subsidy',
        );
    }
    
    public static function getAll($dbh) {
        $sql = "SELECT * FROM mis_subsidy WHERE deleted = ? ORDER BY sort";
        $parameters = array(0);
        $sth = Db\Util::execute($dbh, $sql, $parameters);
        $subsidies = $sth->fetchAll();
        
        $subsidies2 = array();
        foreach ($subsidies as $subsidy) {
            $subsidies2[$subsidy['type']][] = $subsidy;
        }
        return $subsidies2;
    }
}