FM / autoload

/home/techb158/exp.abdallabala.com/application/autoload/

/home/techb158/exp.abdallabala.com/application/autoload

Name	Size	Mode	Actions
Ib/	-	0755	rm
IBilling/	-	0755	rm
Models/	-	0755	rm
Notify/	-	0755	rm
Admin.php	1626	0644	edit dl rm
App.php	87	0644	edit dl rm
Arr.php	416	0644	edit dl rm
Asset.php	1822	0644	edit dl rm
Auth.php	1246	0644	edit dl rm
Backup.php	11650	0644	edit dl rm
Cache.php	84	0644	edit dl rm
Ccavenue.php	8458	0644	edit dl rm
class.smtp.php	39438	0644	edit dl rm
Companies.php	2564	0644	edit dl rm
Contacts.php	6607	0644	edit dl rm
Countries.php	31152	0644	edit dl rm
Currency.php	23237	0644	edit dl rm
Dashboard.php	20625	0644	edit dl rm
DB.php	62	0644	edit dl rm
Demo.php	24844	0644	edit dl rm
Dev.php	1666	0644	edit dl rm
Ed.php	1758	0644	edit dl rm
Event.php	449	0644	edit dl rm
ExtendedZip.php	1381	0644	edit dl rm
Finance.php	5874	0644	edit dl rm
Fsubmit.php	4489	0644	edit dl rm
Gravatar.php	2721	0644	edit dl rm
Image.php	69395	0644	edit dl rm
index.html	112	0644	edit dl rm
Invoice.php	15557	0644	edit dl rm
Make.php	966	0644	edit dl rm
Misc.php	1385	0644	edit dl rm
Model.php	23728	0644	edit dl rm
ORM.php	84036	0644	edit dl rm
Paginator.php	6122	0644	edit dl rm
parseCSV.php	39009	0644	edit dl rm
Parsedown.php	38137	0644	edit dl rm
Password.php	2136	0644	edit dl rm
PHPMailer.php	111411	0644	edit dl rm
Plugins.php	2973	0644	edit dl rm
Quote.php	8090	0644	edit dl rm
Reorder.php	2017	0644	edit dl rm
Repeating.php	5771	0644	edit dl rm
Schema.php	4899	0644	edit dl rm
Sms.php	1047	0644	edit dl rm
Syscpanel.php	6058	0644	edit dl rm
Syscurl.php	1075	0644	edit dl rm
Sysfile.php	579	0644	edit dl rm
Tags.php	831	0644	edit dl rm
Template.php	540	0644	edit dl rm
Timezone.php	1171	0644	edit dl rm
Transaction.php	1073	0644	edit dl rm
Uploader.php	3369	0644	edit dl rm
User.php	374	0644	edit dl rm
Util.php	9760	0644	edit dl rm
Validator.php	8634	0644	edit dl rm
View.php	2170	0644	edit dl rm

Edit: /home/techb158/exp.abdallabala.com/application/autoload/Model.php (23728B)

<?php
/**
 *
 * Paris
 *
 * http://github.com/j4mie/paris/
 *
 * A simple Active Record implementation built on top of Idiorm
 * ( http://github.com/j4mie/idiorm/ ).
 *
 * You should include Idiorm before you include this file:
 * require_once 'your/path/to/idiorm.php';
 *
 * BSD Licensed.
 *
 * Copyright (c) 2010, Jamie Matthews
 * 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.
 *
 * 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.
 *
 */
/**
 * Subclass of Idiorm's ORM class that supports
 * returning instances of a specified class rather
 * than raw instances of the ORM class.
 *
 * You shouldn't need to interact with this class
 * directly. It is used internally by the Model base
 * class.
 */
class ORMWrapper extends ORM {
    /**
     * The wrapped find_one and find_many classes will
     * return an instance or instances of this class.
     *
     * @var string $_class_name
     */
    protected $_class_name;
    /**
     * Set the name of the class which the wrapped
     * methods should return instances of.
     *
     * @param  string $class_name
     * @return void
     */
    public function set_class_name($class_name) {
        $this->_class_name = $class_name;
    }
    /**
     * Add a custom filter to the method chain specified on the
     * model class. This allows custom queries to be added
     * to models. The filter should take an instance of the
     * ORM wrapper as its first argument and return an instance
     * of the ORM wrapper. Any arguments passed to this method
     * after the name of the filter will be passed to the called
     * filter function as arguments after the ORM class.
     *
     * @return ORMWrapper
     */
    public function filter() {
        $args = func_get_args();
        $filter_function = array_shift($args);
        array_unshift($args, $this);
        if (method_exists($this->_class_name, $filter_function)) {
            return call_user_func_array(array($this->_class_name, $filter_function), $args);
        }
    }
    /**
     * Factory method, return an instance of this
     * class bound to the supplied table name.
     *
     * A repeat of content in parent::for_table, so that
     * created class is ORMWrapper, not ORM
     *
     * @param  string $table_name
     * @param  string $connection_name
     * @return ORMWrapper
     */
    public static function for_table($table_name, $connection_name = parent::DEFAULT_CONNECTION) {
        self::_setup_db($connection_name);
        return new self($table_name, array(), $connection_name);
    }
    /**
     * Method to create an instance of the model class
     * associated with this wrapper and populate
     * it with the supplied Idiorm instance.
     *
     * @param  ORM $orm
     * @return bool|Model
     */
    protected function _create_model_instance($orm) {
        if ($orm === false) {
            return false;
        }
        $model = new $this->_class_name();
        $model->set_orm($orm);
        return $model;
    }
    /**
     * Wrap Idiorm's find_one method to return
     * an instance of the class associated with
     * this wrapper instead of the raw ORM class.
     *
     * @param  null|integer $id
     * @return Model
     */
    public function find_one($id=null) {
        return $this->_create_model_instance(parent::find_one($id));
    }
    /**
     * Wrap Idiorm's find_many method to return
     * an array of instances of the class associated
     * with this wrapper instead of the raw ORM class.
     *
     * @return Array
     */
    public function find_many() {
        $results = parent::find_many();
        foreach($results as $key => $result) {
            $results[$key] = $this->_create_model_instance($result);
        }
        return $results;
    }
    /**
     * Wrap Idiorm's create method to return an
     * empty instance of the class associated with
     * this wrapper instead of the raw ORM class.
     *
     *  return ORMWrapper|bool
     */
    public function create($data=null) {
        return $this->_create_model_instance(parent::create($data));
    }
}
/**
 * Model base class. Your model objects should extend
 * this class. A minimal subclass would look like:
 *
 * class Widget extends Model {
 * }
 *
 */
class Model {
    // Default ID column for all models. Can be overridden by adding
    // a public static _id_column property to your model classes.
    const DEFAULT_ID_COLUMN = 'id';
    // Default foreign key suffix used by relationship methods
    const DEFAULT_FOREIGN_KEY_SUFFIX = '_id';
    /**
     * Set a prefix for model names. This can be a namespace or any other
     * abitrary prefix such as the PEAR naming convention.
     *
     * @example Model::$auto_prefix_models = 'MyProject_MyModels_'; //PEAR
     * @example Model::$auto_prefix_models = '\MyProject\MyModels\'; //Namespaces
     *
     * @var string $auto_prefix_models
     */
    public static $auto_prefix_models = null;
    /**
     * The ORM instance used by this model
     * instance to communicate with the database.
     *
     * @var ORM $orm
     */
    public $orm;
    /**
     * Retrieve the value of a static property on a class. If the
     * class or the property does not exist, returns the default
     * value supplied as the third argument (which defaults to null).
     *
     * @param  string      $class_name
     * @param  string      $property
     * @param  null|string $default
     * @return string
     */
    protected static function _get_static_property($class_name, $property, $default=null) {
        if (!class_exists($class_name) || !property_exists($class_name, $property)) {
            return $default;
        }
        $properties = get_class_vars($class_name);
        return $properties[$property];
    }
    /**
     * Static method to get a table name given a class name.
     * If the supplied class has a public static property
     * named $_table, the value of this property will be
     * returned.
     *
     * If not, the class name will be converted using
     * the _class_name_to_table_name method method.
     *
     * If public static property $_table_use_short_name == true
     * then $class_name passed to _class_name_to_table_name is
     * stripped of namespace information.
     *
     * @param  string $class_name
     * @return string
     */
    protected static function _get_table_name($class_name) {
        $specified_table_name = self::_get_static_property($class_name, '_table');
        $use_short_class_name =
            self::_get_static_property($class_name, '_table_use_short_name');
        if ($use_short_class_name) {
            $exploded_class_name = explode('\\', $class_name);
            $class_name = end($exploded_class_name);
        }
        if (is_null($specified_table_name)) {
            return self::_class_name_to_table_name($class_name);
        }
        return $specified_table_name;
    }
    /**
     * Convert a namespace to the standard PEAR underscore format.
     *
     * Then convert a class name in CapWords to a table name in
     * lowercase_with_underscores.
     *
     * Finally strip doubled up underscores
     *
     * For example, CarTyre would be converted to car_tyre. And
     * Project\Models\CarTyre would be project_models_car_tyre.
     *
     * @param  string $class_name
     * @return string
     */
    protected static function _class_name_to_table_name($class_name) {
        return strtolower(preg_replace(
            array('/\\\\/', '/(?<=[a-z])([A-Z])/', '/__/'),
            array('_', '_$1', '_'),
            ltrim($class_name, '\\')
        ));
    }
    /**
     * Return the ID column name to use for this class. If it is
     * not set on the class, returns null.
     *
     * @param  string $class_name
     * @return string|null
     */
    protected static function _get_id_column_name($class_name) {
        return self::_get_static_property($class_name, '_id_column', self::DEFAULT_ID_COLUMN);
    }
    /**
     * Build a foreign key based on a table name. If the first argument
     * (the specified foreign key column name) is null, returns the second
     * argument (the name of the table) with the default foreign key column
     * suffix appended.
     *
     * @param  string $specified_foreign_key_name
     * @param  string $table_name
     * @return string
     */
    protected static function _build_foreign_key_name($specified_foreign_key_name, $table_name) {
        if (!is_null($specified_foreign_key_name)) {
            return $specified_foreign_key_name;
        }
        return $table_name . self::DEFAULT_FOREIGN_KEY_SUFFIX;
    }
    /**
     * Factory method used to acquire instances of the given class.
     * The class name should be supplied as a string, and the class
     * should already have been loaded by PHP (or a suitable autoloader
     * should exist). This method actually returns a wrapped ORM object
     * which allows a database query to be built. The wrapped ORM object is
     * responsible for returning instances of the correct class when
     * its find_one or find_many methods are called.
     *
     * @param  string      $class_name
     * @param  null|string $connection_name
     * @return ORMWrapper
     */
    public static function factory($class_name, $connection_name = null) {
        $class_name = self::$auto_prefix_models . $class_name;
        $table_name = self::_get_table_name($class_name);
        if ($connection_name == null) {
            $connection_name = self::_get_static_property(
                $class_name,
                '_connection_name',
                ORMWrapper::DEFAULT_CONNECTION
            );
        }
        $wrapper = ORMWrapper::for_table($table_name, $connection_name);
        $wrapper->set_class_name($class_name);
        $wrapper->use_id_column(self::_get_id_column_name($class_name));
        return $wrapper;
    }
    /**
     * Internal method to construct the queries for both the has_one and
     * has_many methods. These two types of association are identical; the
     * only difference is whether find_one or find_many is used to complete
     * the method chain.
     *
     * @param  string      $associated_class_name
     * @param  null|string $foreign_key_name
     * @param  null|string $foreign_key_name_in_current_models_table
     * @param  null|string $connection_name
     * @return ORMWrapper
     */
    protected function _has_one_or_many($associated_class_name, $foreign_key_name=null, $foreign_key_name_in_current_models_table=null, $connection_name=null) {
        $base_table_name = self::_get_table_name(get_class($this));
        $foreign_key_name = self::_build_foreign_key_name($foreign_key_name, $base_table_name);

$where_value = ''; //Value of foreign_table.{$foreign_key_name} we're
        //looking for. Where foreign_table is the actual
        //database table in the associated model.

if(is_null($foreign_key_name_in_current_models_table)) {
            //Match foreign_table.{$foreign_key_name} with the value of
            //{$this->_table}.{$this->id()}
            $where_value = $this->id();
        } else {
            //Match foreign_table.{$foreign_key_name} with the value of
            //{$this->_table}.{$foreign_key_name_in_current_models_table}
            $where_value = $this->$foreign_key_name_in_current_models_table;
        }

return self::factory($associated_class_name, $connection_name)->where($foreign_key_name, $where_value);
    }
    /**
     * Helper method to manage one-to-one relations where the foreign
     * key is on the associated table.
     *
     * @param  string      $associated_class_name
     * @param  null|string $foreign_key_name
     * @param  null|string $foreign_key_name_in_current_models_table
     * @param  null|string $connection_name
     * @return ORMWrapper
     */
    protected function has_one($associated_class_name, $foreign_key_name=null, $foreign_key_name_in_current_models_table=null, $connection_name=null) {
        return $this->_has_one_or_many($associated_class_name, $foreign_key_name, $foreign_key_name_in_current_models_table, $connection_name);
    }
    /**
     * Helper method to manage one-to-many relations where the foreign
     * key is on the associated table.
     *
     * @param  string      $associated_class_name
     * @param  null|string $foreign_key_name
     * @param  null|string $foreign_key_name_in_current_models_table
     * @param  null|string $connection_name
     * @return ORMWrapper
     */
    protected function has_many($associated_class_name, $foreign_key_name=null, $foreign_key_name_in_current_models_table=null, $connection_name=null) {
        return $this->_has_one_or_many($associated_class_name, $foreign_key_name, $foreign_key_name_in_current_models_table, $connection_name);
    }
    /**
     * Helper method to manage one-to-one and one-to-many relations where
     * the foreign key is on the base table.
     *
     * @param  string      $associated_class_name
     * @param  null|string $foreign_key_name
     * @param  null|string $foreign_key_name_in_associated_models_table
     * @param  null|string $connection_name
     * @return $this|null
     */
    protected function belongs_to($associated_class_name, $foreign_key_name=null, $foreign_key_name_in_associated_models_table=null, $connection_name=null) {
        $associated_table_name = self::_get_table_name(self::$auto_prefix_models . $associated_class_name);
        $foreign_key_name = self::_build_foreign_key_name($foreign_key_name, $associated_table_name);
        $associated_object_id = $this->$foreign_key_name;

$desired_record = null;

if( is_null($foreign_key_name_in_associated_models_table) ) {
            //"{$associated_table_name}.primary_key = {$associated_object_id}"
            //NOTE: primary_key is a placeholder for the actual primary key column's name
            //in $associated_table_name
            $desired_record = self::factory($associated_class_name, $connection_name)->where_id_is($associated_object_id);
        } else {
            //"{$associated_table_name}.{$foreign_key_name_in_associated_models_table} = {$associated_object_id}"
            $desired_record = self::factory($associated_class_name, $connection_name)->where($foreign_key_name_in_associated_models_table, $associated_object_id);
        }

return $desired_record;
    }
    /**
     * Helper method to manage many-to-many relationships via an intermediate model. See
     * README for a full explanation of the parameters.
     *
     * @param  string      $associated_class_name
     * @param  null|string $join_class_name
     * @param  null|string $key_to_base_table
     * @param  null|string $key_to_associated_table
     * @param  null|string $key_in_base_table
     * @param  null|string $key_in_associated_table
     * @param  null|string $connection_name
     * @return ORMWrapper
     */
    protected function has_many_through($associated_class_name, $join_class_name=null, $key_to_base_table=null, $key_to_associated_table=null,  $key_in_base_table=null, $key_in_associated_table=null, $connection_name=null) {
        $base_class_name = get_class($this);
        // The class name of the join model, if not supplied, is
        // formed by concatenating the names of the base class
        // and the associated class, in alphabetical order.
        if (is_null($join_class_name)) {
            $model = explode('\\', $base_class_name);
            $model_name = end($model);
            if (substr($model_name, 0, strlen(self::$auto_prefix_models)) == self::$auto_prefix_models) {
                $model_name = substr($model_name, strlen(self::$auto_prefix_models), strlen($model_name));
            }
            $class_names = array($model_name, $associated_class_name);
            sort($class_names, SORT_STRING);
            $join_class_name = join("", $class_names);
        }
        // Get table names for each class
        $base_table_name = self::_get_table_name($base_class_name);
        $associated_table_name = self::_get_table_name(self::$auto_prefix_models . $associated_class_name);
        $join_table_name = self::_get_table_name(self::$auto_prefix_models . $join_class_name);
        // Get ID column names
        $base_table_id_column = (is_null($key_in_base_table)) ?
            self::_get_id_column_name($base_class_name) :
            $key_in_base_table;
        $associated_table_id_column = (is_null($key_in_associated_table)) ?
            self::_get_id_column_name(self::$auto_prefix_models . $associated_class_name) :
            $key_in_associated_table;
        // Get the column names for each side of the join table
        $key_to_base_table = self::_build_foreign_key_name($key_to_base_table, $base_table_name);
        $key_to_associated_table = self::_build_foreign_key_name($key_to_associated_table, $associated_table_name);

/*
            "   SELECT {$associated_table_name}.*
                  FROM {$associated_table_name} JOIN {$join_table_name}
                    ON {$associated_table_name}.{$associated_table_id_column} = {$join_table_name}.{$key_to_associated_table}
                 WHERE {$join_table_name}.{$key_to_base_table} = {$this->$base_table_id_column} ;"
        */
        return self::factory($associated_class_name, $connection_name)
            ->select("{$associated_table_name}.*")
            ->join($join_table_name, array("{$associated_table_name}.{$associated_table_id_column}", '=', "{$join_table_name}.{$key_to_associated_table}"))
            ->where("{$join_table_name}.{$key_to_base_table}", $this->$base_table_id_column); ;
    }
    /**
     * Set the wrapped ORM instance associated with this Model instance.
     *
     * @param  ORM $orm
     * @return void
     */
    public function set_orm($orm) {
        $this->orm = $orm;
    }
    /**
     * Magic getter method, allows $model->property access to data.
     *
     * @param  string $property
     * @return null|string
     */
    public function __get($property) {
        return $this->orm->get($property);
    }
    /**
     * Magic setter method, allows $model->property = 'value' access to data.
     *
     * @param  string $property
     * @param  string $value
     * @return void
     */
    public function __set($property, $value) {
        $this->orm->set($property, $value);
    }
    /**
     * Magic isset method, allows isset($model->property) to work correctly.
     *
     * @param  string $property
     * @return bool
     */
    public function __isset($property) {
        return $this->orm->__isset($property);
    }
    /**
     * Getter method, allows $model->get('property') access to data
     *
     * @param  string $property
     * @return string
     */
    public function get($property) {
        return $this->orm->get($property);
    }
    /**
     * Setter method, allows $model->set('property', 'value') access to data.
     *
     * @param  string|array $property
     * @param  string|null  $value
     * @return Model
     */
    public function set($property, $value = null) {
        $this->orm->set($property, $value);
        return $this;
    }
    /**
     * Setter method, allows $model->set_expr('property', 'value') access to data.
     *
     * @param  string|array $property
     * @param  string|null  $value
     * @return Model
     */
    public function set_expr($property, $value = null) {
        $this->orm->set_expr($property, $value);
        return $this;
    }
    /**
     * Check whether the given field has changed since the object was created or saved
     *
     * @param  string $property
     * @return bool
     */
    public function is_dirty($property) {
        return $this->orm->is_dirty($property);
    }
    /**
     * Check whether the model was the result of a call to create() or not
     *
     * @return bool
     */
    public function is_new() {
        return $this->orm->is_new();
    }
    /**
     * Wrapper for Idiorm's as_array method.
     *
     * @return Array
     */
    public function as_array() {
        $args = func_get_args();
        return call_user_func_array(array($this->orm, 'as_array'), $args);
    }
    /**
     * Save the data associated with this model instance to the database.
     *
     * @return null
     */
    public function save() {
        return $this->orm->save();
    }
    /**
     * Delete the database row associated with this model instance.
     *
     * @return null
     */
    public function delete() {
        return $this->orm->delete();
    }
    /**
     * Get the database ID of this model instance.
     *
     * @return integer
     */
    public function id() {
        return $this->orm->id();
    }
    /**
     * Hydrate this model instance with an associative array of data.
     * WARNING: The keys in the array MUST match with columns in the
     * corresponding database table. If any keys are supplied which
     * do not match up with columns, the database will throw an error.
     *
     * @param  Array $data
     * @return void
     */
    public function hydrate($data) {
        $this->orm->hydrate($data)->force_all_dirty();
    }
    /**
     * Calls static methods directly on the ORMWrapper
     *
     * @param  string $method
     * @param  Array  $parameters
     * @return Array
     */
    public static function __callStatic($method, $parameters) {
        if(function_exists('get_called_class')) {
            $model = self::factory(get_called_class());
            return call_user_func_array(array($model, $method), $parameters);
        }
    }
    /**
     * Magic method to capture calls to undefined class methods.
     * In this case we are attempting to convert camel case formatted
     * methods into underscore formatted methods.
     *
     * This allows us to call methods using camel case and remain
     * backwards compatible.
     *
     * @param  string $name
     * @param  array  $arguments
     * @throws ParisMethodMissingException
     * @return bool|ORMWrapper
     */
    public function __call($name, $arguments) {
        $method = strtolower(preg_replace('/([a-z])([A-Z])/', '$1_$2', $name));
        if (method_exists($this, $method)) {
            return call_user_func_array(array($this, $method), $arguments);
        } else {
            throw new ParisMethodMissingException("Method $name() does not exist in class " . get_class($this));
        }
    }
}
class ParisMethodMissingException extends Exception {}

cmd: