onetipp - www.onetopp.com - mana4444sdfage - webservice - SOURCE CODE

<?php
namespace Application\Exceptions;
/**
 * UserDoesNotExist
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class AuthenticationFailure extends \Core\Exceptions\WebServiceException {

    /**
     * Creates duplicate name exception
     *
     */
    public function __construct() {
        parent::__construct("Authentication failure");
    }

}

<?php
namespace Application\Exceptions;
/**
 * UserDoesNotExist
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class BadJsonFilter extends \Core\Exceptions\WebServiceException {

    /**
     * Creates exception
     */
    public function __construct() {
        parent::__construct("The JSON you have provided is invalid");
    }

}

<?php
namespace Application\Exceptions;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class BadTarArchive extends \Core\Exceptions\WebServiceException {

    public function __construct($filename) {
        parent::__construct("Bad tar archive $filename");
    }

}

<?php
namespace Application\Exceptions;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class CouldNotImport extends \Core\Exceptions\WebServiceException {
    public function __construct($reason) {
        parent::__construct("Could not import: " . $reason);
    }
}

<?php
namespace Application\Exceptions;
/**
 * UserDoesNotExist
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class DuplicateName extends \Core\Exceptions\WebServiceException {

    /**
     * Creates duplicate name exception
     *
     */
    public function __construct() {
        parent::__construct("Duplicate name exists");
    }

}

<?php
/**
 * @author <volaru@bitdefender.com>
 */

namespace Application\Exceptions;


class InsufficientRightsException extends \Core\Exceptions\WebServiceException {

}

<?php
namespace Application\Exceptions;
/**
 * UserDoesNotExist
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class WrongArgumentType extends \Core\Exceptions\WebServiceException {

    /**
     * Creates exception
     *
     * @param string $argumentName The name of the argument
     */
    public function __construct($argumentName) {
        parent::__construct("Parameter `$argumentName` has wrong type");
    }

}

<?php
namespace Application\Exceptions;
/**
 * UserDoesNotExist
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class WrongArgumentValue extends \Core\Exceptions\WebServiceException {

    /**
     * Creates exception
     *
     * @param string $argumentName The name of the argument
     */
    public function __construct($argumentName) {
        parent::__construct("Parameter `$argumentName` has wrong value");
    }

}

<?php
namespace Core\Database;
/**
 * Abstract Driver Class for Database connection
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
interface IDriver {

    /**
     * Creates new Driver object with given config
     *
     * @param array $config The config array
     */
    public function __construct($config);

    /**
     * Creates the connection to the database
     * Throws exception on failure
     * */
    public function connect();

    /**
     * Executes a select statement with binding parameters
     *
     * @param string $query The SQL query to be executed
     * @param array $params An array of params to be sent to the query
     * @return array The result rows, throws exception on failure
     * */
    public function query($query, array $params);

    /**
     * Execute an insert,update or delete statement with binding parameters
     *
     * @param string $query The query to be executed
     * @param array $params The params to be sent to the query
     * @return int number of affected rows if success, throws exception on failure
     * */
    public function execute($query, array $params);

    /**
     * Returns the id of the last inserted row or sequence value
     *
     * @return int
     * */
    public function getLastInsertId();

    /**
     * Builds a query from a QueryBuilder object and executes it, returning the result
     *

... [truncated, 47 more lines] ...

<?php
namespace Core\Database;
/**
 * QueryBuilder
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
abstract class QueryBuilder {

    const LEFT_JOIN = 1;
    const RIGHT_JOIN = 2;

    /**
     * @var array The tables to select from
     */
    protected $_tables;

    /**
     * @var array The where conditions
     */
    protected $_whereConditions;

    /**
     * @var \Core\Database The database object
     */
    protected $_database;

    /**
     * Clears the internal representation of the query
     *
     * @return QueryBuilder this for method chaining
     */
    abstract function reset();

    /**
     * Creates the QueryBuilder and resets it's contents
     */
    public function __construct(\Core\Database $database) {
        $this->reset();
        $this->_database = $database;
    }

    /**
     * Sets the table or tables to select from.
     * If you need to specify the ON condition, then you must pass an array where the key is the table name and the value
     * is an array containing the 2 fields to equal in the ON condition
     *
     * @param string|array $table The table name or an array of tables
     * @return QueryBuilder this for method chaining
     */

... [truncated, 186 more lines] ...

<?php
namespace Core\DescriptionWriter;
use Core\Logger;

/**
 * ExtDirect
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ExtDirect extends \Core\DescriptionWriter {

    /**
     * Write the description
     *
     * @param array $description The array of described classes->methods->params
     * @param string $namespace The namespace of the classes
     * @param array $namespaces The list of all namespaces
     * @return string The description
     */
    function write($description, $namespace, $namespaces) {

        // convert API config to Ext.Direct spec
        $actions = array();

        foreach ($description as $className => &$classMethods) {

            $methods = array();

            foreach ($classMethods as $methodName=> &$methodDetails) {
                $params = array();
                $pos    = 0;
                foreach ($methodDetails['parameters'] as $param) {
                    $params[] = array(
                        'name' => $param['name'],
                        'type' => $param['type'],
                        'pos'  => $pos
                    );
                    $pos++;
                }

                $methods[] = array(
                    'name'        => $methodName,
                    'len'         => count($methodDetails['parameters']),
                    'params'      => $params,
                    'formHandler' => $methodDetails['formHandler']
                );

            }

            $actions[$className] = $methods;

... [truncated, 39 more lines] ...

<?php
namespace Core\DescriptionWriter;
/**
 * Html
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class Html extends \Core\DescriptionWriter {

    /**
     * Write the description
     *
     * @param $description The array of described classes->methods->params
     * @param $namespace The namespace of the classes
     * @param array $namespaces The list of all namespaces
     * @return string The description
     */
    public function write($description, $namespace, $namespaces) {
        ob_start();
        include realpath(dirname(__FILE__) . '/description.phtml');
        ob_end_flush();
    }

}

<?php
namespace Core\Exceptions;
/**
 * ArrayKeyMissingException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ArrayKeyMissingException extends \Exception {

    public function __construct($keyName, $arrayName = null) {
        parent::__construct("Array key $keyName is missing" . ($arrayName?" from $arrayName":''));
    }
}

<?php
namespace Core\Exceptions;
/**
 * DatabaseExceptionException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class DatabaseException extends \Exception {

}

<?php
namespace Core\Exceptions;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class FileDoesNotExistException extends \Exception {

    public function __construct($file) {
        parent::__construct("Filename '$file' does not exist");
    }
}

<?php
namespace Core\Exceptions;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class LogLevelDoesNotExistException extends \Exception {
    public function __construct($logLevel) {
        parent::__construct("Log level '$logLevel' does not exist");
    }
}

<?php
namespace Core\Exceptions;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class PropertyDoesNotExistException extends \Exception {
    public function __construct($class, $property) {
        parent::__construct("Class '$class' does not have property '$property'");
    }
}

<?php
namespace Core\Exceptions;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ReadOnlyKeyException extends \Exception {
    public function __construct($class, $key) {
        parent::__construct("Array of type '$class' has key '$key' read-only");
    }
}

<?php
namespace Core\Exceptions;

/**
 * RequsetMethodNotValidException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class RequestMethodNotValidException extends \Exception {

    /**
     * Request Method not valid Exception
     *
     * @param string $expectedMethod The Expected Request Method
     * @param string $receivedMethod The Received Request Method
     */
    public function __construct($expectedMethod, $receivedMethod) {
        parent::__construct("Expecting `$expectedMethod`, received `$receivedMethod`");
    }

}

<?php
namespace Core\Exceptions;
/**
 * RequestNotValidException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class RequestNotValidException extends \Exception {

    /**
     * Used for describing the error of a key
     */
    const DOES_NOT_EXIST = 1;

    /**
     * Used for describing the error of a key
     */
    const NOT_VALID = 2;

    /**
     * @param string $key The key of the request array that has errors
     * @param int $type The type of error ( does not exist / not valid )
     */
    public function __construct($key, $type) {
        switch ($type) {
            case self::DOES_NOT_EXIST:
                $messageType = 'does not exist';
                break;
            case self::NOT_VALID:
                $messageType = 'is not valid';
                break;
        }
        parent::__construct("The '" . $key . "' " . $messageType);
    }

}

<?php
namespace Core\Exceptions;
/**
 * RouterMethodException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class RouterException extends \Exception {

    /**
     * Method does not exist
     */
    const DOES_NOT_EXIST = 1;

    /**
     * Method is not accessible ( is not public or static )
     */
    const NOT_ACCESSIBLE = 2;

    /**
     * Method has missing parameters
     */
    const MISSING_PARAMETERS = 3;

    /**
     * @param string $object The name of the object that has errors
     * @param int $type The type of error, one of the class constants
     */
    public function __construct($object, $type) {

        switch ($type) {
            case self::DOES_NOT_EXIST:
                $message = 'does not exist';
                break;
            case self::NOT_ACCESSIBLE:
                $message = 'is not accessible';
                break;
            case self::MISSING_PARAMETERS:
                $message = 'has missing parameters';
                break;
        }
        parent::__construct("'$object' $message");
    }

}

<?php
namespace Core\Exceptions;
/**
 * WebServiceException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
abstract class WebServiceException extends \Exception {

}

<?php
namespace Core\Exceptions;
/**
 * WrongDataTypeException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class WrongDataTypeException extends \Exception {
    public function __construct($variable, $expected, $received) {
        parent::__construct("Wrong data type for '$variable', expecting '$expected', got '$received'");
    }
}

<?php
namespace Core\Exceptions;
/**
 * WrongParameterException
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class WrongParameterException extends \Exception {
    public function __construct($class, $method, $parameter, $expected, $got) {
        parent::__construct("Wrong value for parameter $parameter in $class::$method. Expected: $expected, got: $got");
    }
}

<?php
namespace Core\InputReader;
/**
 * ExtDirect InputReader
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ExtDirect extends HTTP {

    /**
     * @var string The thread id of the ExtDirect request
     */
    protected $_tid;

    /**
     * @var bool Specifies if the request is sent from a form or from AJAX
     */
    protected $_isForm;

    /**
     * @var bool Specifies if the request is an upload request
     */
    protected $_isUpload;

    /**
     * Gets the Tid
     *
     * @return string
     */
    public function getTid() {
        return $this->_tid;
    }

    /**
     * Gets if request is from a form
     *
     * @return bool True if request is from a form, false otherwise
     */
    public function isForm() {
        return $this->_isForm;
    }

    /**
     * Gets if request is from a form upload
     *
     * @return bool True if request is an upload request, false otherwise
     */
    public function isUpload() {
        return $this->_isUpload;
    }

... [truncated, 64 more lines] ...

<?php
namespace Core\InputReader;
/**
 * ExtJs
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ExtJs extends HTTP {

    /**
     * Reads the request info for ExtJs protocol and sets internal properties
     *
     * @throws \Core\Exceptions\RequestNotValidException
     */
    public function _readRequest() {

        // basic HTTP handler
        parent::_readRequest();

        // request fields names
        $requestFields = array('class', 'method');

        // create an array with request fields as keys
        $requestFieldsKeys = array_fill_keys($requestFields, null);

        // check to see if request fields are sent
        foreach ($requestFields as $key) {
            if (!isset($_REQUEST[$key]) || $_REQUEST[$key] === '') {
                throw new \Core\Exceptions\RequestNotValidException($key, \Core\Exceptions\RequestNotValidException::DOES_NOT_EXIST);
            }
        }

        $this->_class  = $_REQUEST['class'];
        $this->_method = $_REQUEST['method'];

        // get the other parameters from $_REQUEST
        $this->_arguments = array_diff_key($_REQUEST, $requestFieldsKeys);

        // depending on the request method, parameters will be decoded differently
        if ($_SERVER['REQUEST_METHOD'] == 'POST') {

            switch ($_SERVER['CONTENT_TYPE']) {
                case 'application/json':
                    $content          = file_get_contents('php://input');
                    $this->_arguments = array_merge($this->_arguments, json_decode($content, true));
                    break;

                case 'application/x-www-form-urlencoded':
                    $this->_arguments = array_merge($this->_arguments, $_POST);
                    break;

... [truncated, 13 more lines] ...

<?php
namespace Core\InputReader;

/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
abstract class HTTP extends \Core\InputReader {

    /**
     * Basic handler for HTTP input
     */
    protected function _readRequest(){

        // Access-Control-Allow-Origin response header should be set every time Origin header is
        // sent, no matter what the request method was!
        // Also if Origin was set, most probably Access-Control-Allow-Credentials is also
        // requested (because ExtJS.Ajax.withCredentials is set to true, indicating that
        // cookies should also be sent with the request)

        if (isset($_SERVER['HTTP_ORIGIN'])){
            header('Access-Control-Allow-Origin: ' . $_SERVER['HTTP_ORIGIN']);
            header('Access-Control-Allow-Credentials: true');
        }
        // first request is OPTIONS and the following headers must be sent as response
        if ($_SERVER['REQUEST_METHOD'] == 'OPTIONS') {
            header('Access-Control-Allow-Methods: POST, GET , OPTIONS');
            header('Access-Control-Allow-Headers: X-Requested-With, Content-Type');
            exit();
        }


    }

}

<?php
namespace Core\Logger;

/**
 * IWriter - Logger Writer Interface
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
interface IWritter {

    /**
     *  Writes log message
     *
     * @param int $level The level to witch the message is written
     * @param string $prefix Prefix to be added before message
     * @param string $msg Message to be written. More arguments may follow message.
     */
    public function write($level, $prefix, $message);
}

<?php
namespace Core\OutputWriter;
/**
 * ExtDirect
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ExtDirect extends \Core\OutputWriter {

    protected function _setHeaders() {

        $origin = isset($_SERVER['HTTP_REFERER'])?$_SERVER['HTTP_REFERER']:$_SERVER['HTTP_ORIGIN'];

        // for cross-domain requests
        header('Access-Control-Allow-Origin: ' . $origin);
        header('Access-Control-Allow-Methods: POST, GET , OPTIONS');
        header('Access-Control-Allow-Headers: X-Requested-With, Content-Type, X-File-Name');
        header('Access-Control-Allow-Credentials: true');

        header('Content-Type: text/javascript');

    }


    /**
     * Writes the response
     */
    protected function _writeResponse() {

        $this->_setHeaders();

        // if response is successful then send result response
        $response = array(
            'type'   => 'rpc',
            'tid'    => $this->_inputReader->getTid(),
            'action' => $this->_inputReader->getClass(),
            'method' => $this->_inputReader->getMethod(),
            'result' => $this->_response
        );

        // echo response as JSON
        echo json_encode($response);
    }

    /**
     * Writes an exception
     */
    protected function _writeException() {

        $this->_setHeaders();

... [truncated, 14 more lines] ...

<?php
namespace Core\OutputWriter;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ExtJs extends \Core\OutputWriter {

    /**
     * Sets response with given data
     */
    protected function _writeResponse() {

        $callback = null;

        // when using JSONP proxy the callback parameter will be sent
        if (isset($_REQUEST['callback'])) {
            $callback = $_REQUEST['callback'];
        }

        if ($callback) {
            header('Content-Type: text/javascript');
            echo $callback . '(' . json_encode($this->_response) . ');';
        } else {
            header('Content-Type: text/html');
            echo json_encode($this->_response);
        }

    }

    /**
     * Writes an exception
     */
    protected function _writeException() {
        $this->_response = array(
            'success' => false,
            'exception' => get_class($this->_response),
            'message'   => $this->_response->getMessage(),
            'trace'     => $this->_response->getTraceAsString()
        );

        $this->_writeResponse();
    }
}

<?php
namespace Core\OutputWriter;
/**
 * Html
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class Html extends \Core\OutputWriter {

    /**
     * Writes the response
     */
    protected function _writeResponse() {
        // send output to browser with <pre> for nice formatting
        echo "<pre>" . var_export($this->_response, true);
    }

    /**
     * Writes an exception
     */
    protected function _writeException() {
        echo "<pre>" . get_class($this->_response) . PHP_EOL . $this->_response->getMessage() . PHP_EOL . $this->_response->getCode() . PHP_EOL . ' Line: ' . $this->_response->getLine() . ' File: ' . PHP_EOL . $this->_response->getFile();
    }
}

<?php
namespace Core\OutputWriter;
/**
 * ExtJs
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class JsonP extends \Core\OutputWriter {

    /**
     * Writes the response
     */
    protected function _writeResponse() {
        $callback = null;

        // when using JsonP proxy the callback parameter will be sent
        if (isset($_REQUEST['callback'])) {
            $callback = $_REQUEST['callback'];
        }

        if ($callback) {
            header('Content-Type: text/javascript');
            echo $callback . '(' . json_encode($this->_response) . ');';
        } else {
            header('Content-Type: application/x-json');
            echo json_encode($this->_response);
        }
    }

    /**
     * Writes an exception
     */
    protected function _writeException() {
        $this->_writeResponse();
    }
}

<?php
namespace Core\OutputWriter;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class Raw extends \Core\OutputWriter {
    /**
     * Writes the response
     */
    protected function _writeResponse() {
        echo $this->_response;
    }

    /**
     * Writes an exception
     */
    protected function _writeException() {
        echo get_class($this->_response) . PHP_EOL . $this->_response->getMessage() . PHP_EOL . $this->_response->getCode() . PHP_EOL . ' Line: ' . $this->_response->getLine() . ' File: ' . PHP_EOL . $this->_response->getFile();
    }
}

<?php
namespace Core\Router;
/**
 * IsAjax
 *
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class IsAjax extends \Core\Router {

    /**
     * Returns one of the possible routing conditions that should be present in the config
     *
     * @return bool True if request is AJAX, false otherwise
     */
    protected function _getCondition() {
        return isset($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest';
    }
}

<?php
namespace Core\WebServiceHook;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class AfterMethodCallHook extends \Core\AbstractWebServiceHook {

    /**
     * @var mixed
     */
    protected $_result;

    /**
     * @param $result
     */
    public function setResult($result) {
        $this->_result = $result;
    }

    /**
     * @param string $class
     * @param string $method
     * @param array $arguments
     * @return mixed
     */
    public function call($class, $method, $arguments) {
        return call_user_func_array($this->_callback, array($class, $method, $arguments, $this->_result));
    }
}

<?php
namespace Core\WebServiceHook;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class BeforeMethodCallHook extends \Core\AbstractWebServiceHook {

}

<?php
namespace Core\WebServiceHook;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class ExceptionMethodCallHook extends \Core\WebServiceHook\AfterMethodCallHook {

}

<?php
namespace Core\WebServiceHook;
/**
 * @author Victor Olaru <victor.olaru@gmail.com>
 */
class SuccessMethodCallHook extends \Core\WebServiceHook\AfterMethodCallHook {

}

<?php
/**
 * *** BEGIN LICENSE BLOCK *****
 *
 * This file is part of FirePHP (http://www.firephp.org/).
 *
 * Software License Agreement (New BSD License)
 *
 * Copyright (c) 2006-2010, Christoph Dorn
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *
 *     * Redistributions in binary form must reproduce the above copyright notice,
 *       this list of conditions and the following disclaimer in the documentation
 *       and/or other materials provided with the distribution.
 *
 *     * Neither the name of Christoph Dorn nor the names of its
 *       contributors may be used to endorse or promote products derived from this
 *       software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * ***** END LICENSE BLOCK *****
 *
 * @copyright       Copyright (C) 2007-2009 Christoph Dorn
 * @author          Christoph Dorn <christoph@christophdorn.com>
 * @license         http://www.opensource.org/licenses/bsd-license.php
 * @package         FirePHPCore
 */

/**
 * @see http://code.google.com/p/firephp/issues/detail?id=112
 */
if (!defined('E_STRICT')) {
    define('E_STRICT', 2048);
}

... [truncated, 1734 more lines] ...