Who We Are

Extreme Coding - the company that performs impossible commissions in the shortest time given. We don’t mind if we have to travel ten or ten thousands miles to complete the order.
What We Do

At EC we deal with bespoke websites, web based applications and ecommerce websites. Our specialised core system can be tailored to the individuals needs and we are able to execute orders in a time much shorter than any other company can. We are cooperating with media agencies as a quick and reliable outsourcing company as well as developing the websites and applications for individual customers.
Do we perform “rush-less” projects? Each project is a challenge, each challenge is a mission, and every mission is different. It will be an honour for us to fulfil your expectations to the highest level.
<?php defined('SYSTEM') or die('This script cannot be run directly.');

/** 
 * Extreme Coding
 * e-mail: info@extreme-coding.net
 * modified: 2011-06-10
 * 
 * Copyright by Extreme Coding, 2011, http://www.extreme-coding.net
 */

class cAggregator
{
    private static $files_group;
    
    public function __construct()
    {
        if (!is_array(self::$files_group))
        {
            self::$files_group = array();
        }
    }
    
    /**
     * Add file to group
     * @param string $filename File path from web root directory
     * @param bool $complete If group is completed with current file
     * @param null or string (Aggregated file name)
     */
    public function add($filename, $completed = false)
    {
        $result = null;
        
        $pathinfo = pathinfo($filename);
        // if user doesn't want to aggregate javascript files
        if ($pathinfo["extension"] == "js" && Settings::get("javascript_aggregation") == "false")
        {
            $completed = true;
        }
        // if user doesn't want to aggregate css files
        elseif ($pathinfo["extension"] == "css" && Settings::get("css_aggregation") == "false")
        {
            $completed = true;
        }
        
        // add files to array
        if (!empty($filename)) 
        {
            self::$files_group[] = $filename;
        
            //var_export(self::$files_group);
            
            if ($completed) 
            {
                $result = $this->checkGroup();
                // clear group
                self::$files_group = array();
            }
        }
        
        return $result;
    }
    
    /**
     * Finish aggegation and return aggregated file path
     * @return string Aggregated file path
     */
    public function completed()
    {
        if (count(self::$files_group) > 0)
        {
            $result = $this->checkGroup();
            // clear group
            self::$files_group = array();
        }
        else
        {
            $result = false;
        }
        
        return $result;
    }
    
    /**
     * Look for group in database
     * @return string Aggregated file name
     */
    private function checkGroup()
    {
        // temporary array for keeping files order
        $files_group_copy = self::$files_group;
        sort(self::$files_group);

        // get all groups
        $query = Config::$db_client->prepare("
            SELECT
                filename, modified, size, `group`, afile
            FROM
                files_aggregator
            ORDER BY
                `group`");
        $query->execute();
        $rows = $query->fetchAll();
        
        $last_group = "";
        $group = $files = array();
        $found = $changed = false; 
        $counter = count($rows);
        foreach ($rows as $row)
        {
            $counter--;
            
            // check new group
            if (count($files) > 0 && ($last_group != $row["group"] || $counter == 0))
            {
                // add group and files because it's last element in db
                if ($counter == 0)
                {
                    $group[] = $row;
                    $files[] = $row["filename"];
                }
                
                sort($files);
                
                // if group has been found
                if (count(array_diff(self::$files_group, $files)) == 0 && count(self::$files_group) == count($files))
                {
                    $found = true;
                    
                    // if group exists check if files have been changed
                    foreach ($group as $g)
                    {
                        if (@filemtime(CURRENT_DIR.DIRECTORY_SEPARATOR.$g["filename"]) != $g["modified"] || 
                            @filesize(CURRENT_DIR.DIRECTORY_SEPARATOR.$g["filename"]) != $g["size"])
                        {
                            $changed = true;
                            break;                    
                        }
                    }
                    
                    break;
                }
                $files = $group = array();
                $last_group = $row["group"];
            }
            
            $group[] = $row;
            $files[] = $row["filename"];
        }

        // group does not exists
        if (!$found)
        {
            if (count($rows) == 0)
            {
                $group_id = 1;
            }
            else 
            {
                $group_id = $rows[count($rows)-1]["group"]+1;
            }
            
            // create new group in database basis on original files order
            foreach ($files_group_copy as $file)
            {
                $query = Config::$db_client->prepare("
                    INSERT INTO
                        files_aggregator (filename, modified, size, `group`)
                    VALUES
                        (:filename, :modified, :size, :group)");
                $query->bindValue(":filename", $file);
                $query->bindValue(":modified", @filemtime(CURRENT_DIR.DIRECTORY_SEPARATOR.$file));
                $query->bindValue(":size", @filesize(CURRENT_DIR.DIRECTORY_SEPARATOR.$file));
                $query->bindValue(":group", $group_id);
                $query->execute(); 
            }
            
            $afile = $this->aggregate($group_id);
        }
        else 
        {
            $group_id = $group[0]["group"];
            
            // if group information should be updated
            if ($changed)
            {
                foreach ($group as $g)
                {
                    $query = Config::$db_client->prepare("
                        UPDATE
                            files_aggregator 
                        SET
                            modified = :modified, 
                            size = :size
                        WHERE
                            filename = :filename AND
                            `group` = :group
                        LIMIT 1");
                    $query->bindValue(":filename", $g["filename"]);
                    $query->bindValue(":modified", @filemtime(CURRENT_DIR.DIRECTORY_SEPARATOR.$g["filename"]));
                    $query->bindValue(":size", @filesize(CURRENT_DIR.DIRECTORY_SEPARATOR.$g["filename"]));
                    $query->bindValue(":group", $group_id);
                    $query->execute();
                }
                
                $afile = $this->aggregate($group_id);
            }
            else
            {
                $afile = $group[0]["afile"];
            }
        }
        
        // if a file has been deleted - create new one
        if (!file_exists(CURRENT_DIR.DIRECTORY_SEPARATOR.$afile))
        {
            $afile = $this->aggregate($group_id);
        }
        
        return $afile;
    }
    
    /**
     * Aggregate files (group them in one file)
     * @param int $group_id Group ID files to aggregate
     */
    private function aggregate($group_id)
    {
        // ask for files
        $query = Config::$db_client->prepare("
            SELECT
                filename
            FROM
                files_aggregator
            WHERE
                `group` = ?
            ORDER BY 
                id");
        $query->bindValue(1, $group_id);
        $query->execute();
        $code = "";
        $firstfile = "";
        while (false !== ($row = $query->fetch()))
        {
            if (empty($firstfile)) $firstfile = $row["filename"];
            $code .= file_get_contents(CURRENT_DIR.DIRECTORY_SEPARATOR.$row["filename"])."\n";
        }
        
        $info = pathinfo($firstfile);
        
        $relative_dir = trim(Config::$ini->getValue("application", "temp_dir"), DIRECTORY_SEPARATOR).
            DIRECTORY_SEPARATOR."aggregator_".$group_id.".".$info["extension"];
        $path = CURRENT_DIR.DIRECTORY_SEPARATOR.$relative_dir;
        
        // update database
        $query = Config::$db_client->prepare("
            UPDATE 
                files_aggregator
            SET
                afile = ?
            WHERE
                `group` = ?");
        $query->bindValue(1, $relative_dir);
        $query->bindValue(2, $group_id);
        $query->execute();
        
        switch ($info["extension"])
        {
            case "js":
                // minify
                $js = $this->minifyJS($code);
                // save without compression
                FileFunctions::saveFile($path, $js);
                // compress
                FileFunctions::saveFile($path.".jgz", gzencode($js, 9));
                break;
        
            case "css":
                // minify
                $css = $this->minifyCSS($code);
                // save without compression
                FileFunctions::saveFile($path, $css);
                // compress
                FileFunctions::saveFile($path.".cgz", gzencode($css, 9));
                break;
        }
        
        return $relative_dir;
    }
    
    /**
     * Minify JavaScript depending on method
     */
    private function minifyJS($contents)
    {
        $method = Settings::get("javascript_compression");
        switch ($method)
        {
            case "standard":
            case "default":
                try
                {
                    $result = JSMin::minify($contents);
                }
                catch (JSMinException $e) 
                {
                    $result = $contents; 
                } 
                break;
                
            case "high":
                $jsp = new JavaScriptPacker($contents);
                $result = $jsp->pack();
                break;
                
            case "none":
            default:
                $result = $contents;
                break;
        }
        
        return $result;
    }
    
    /**
     * Minify CSS depending on method
     */
    private function minifyCSS($contents)
    {
        $method = Settings::get("css_compression");
        switch ($method)
        {
            case "none":
                $result = $contents;
                break;
                
            case "default":
            default:
                $result = compress_css($contents);
                break;
        }
        
        return $result;
    }
     
    
}

?>