Beispiel #1
0
 /**
  * Loads ARC4 encryption parameters from a file
  *
  * @history
  * 2013.09.30:
  *   (AT)  Initial release
  *
  * @version 2013.09.30
  * @author (AT) Alberto Trevino, Brigham Young Univ. <*****@*****.**>
  * 
  * @param string $filename Config file with ARC4 parameters
  */
 public static function loadParameters($filename)
 {
     $config = new Config($filename);
     $key = $config->value("key");
     if ($key) {
         self::setKey($key);
     }
     self::$magic = (string) $config->value("magic");
     $compress = $config->value("compress");
     Format::strToBool($compress);
     self::$compress = $compress;
 }
Beispiel #2
0
 /**
  * Gets information on the columns in the given table.
  *
  * @history
  * 2013.09.30:
  *   (JPK) Initial release
  * 2013.11.19:
  *   (AT)  Work around OCI driver limitations to obtain column information
  *
  * @version 2013.11.19
  * @author (JPK) Jillian Koontz, Brigham Young Univ. <*****@*****.**>
  * @author (AT) Alberto Trevino, Brigham Young Univ. <*****@*****.**>
  *
  * @param string $table Table name
  * @throws \Cougar\Exceptions\Exception
  * @return array List of column properties
  */
 public function getColumns($table)
 {
     $columns = array();
     switch ($this->pdo->getAttribute(PDO::ATTR_DRIVER_NAME)) {
         case "sqlite":
             # TODO: SQLite driver doesn't support getColumnMeta
             $statement = $this->pdo->prepare("SELECT * FROM " . $table . " LIMIT 1");
             $statement->execute();
             $result = $statement->fetch();
             for ($i = 0; $i < count($result); $i++) {
                 $columns[] = $statement->getColumnMeta($i);
             }
             break;
         case "mysql":
             $statement = $this->pdo->prepare("SELECT * FROM " . $table . " LIMIT 1");
             $statement->execute();
             $result = $statement->fetch();
             for ($i = 0; $i < count($result); $i++) {
                 $columns[] = $statement->getColumnMeta($i);
             }
             break;
         case "oci":
             $statement = $this->pdo->prepare("SELECT COLUMN_NAME, DATA_TYPE, DATA_PRECISION, DATA_SCALE,\n\t\t\t\t\t\t\tNULLABLE\n\t\t\t\t\t\tFROM dba_tab_columns WHERE table_name = :table_name");
             $statement->execute(array(":table_name" => $table));
             $result = $statement->fetchAll(\PDO::FETCH_ASSOC);
             foreach ($result as $raw_column) {
                 $column = array("name" => "", "flags" => array(), "native_type" => "");
                 $column["name"] = $raw_column["COLUMN_NAME"];
                 switch ($raw_column["DATA_TYPE"]) {
                     case "NUMBER":
                     case "LONG":
                     case "LONG RAW":
                         if ($raw_column["DATA_SCALE"] > 0) {
                             $column["native_type"] = "float";
                         } else {
                             $column["native_type"] = "int";
                         }
                         break;
                     case "FLOAT":
                         $column["native_type"] = "float";
                         break;
                     case "DATE":
                     case "TIMESTAMP":
                         $column["native_type"] = "datetime";
                         break;
                     default:
                         if (substr($raw_column["DATA_TYPE"], 0, 9) == "TIMESTAMP") {
                             $column["native_type"] = "datetime";
                         } else {
                             $column["native_type"] = "string";
                         }
                         break;
                 }
                 Format::strToBool($raw_column["NULLABLE"]);
                 if (!$raw_column["NULLABLE"]) {
                     $column["floags"][] = "not_null";
                 }
                 $columns[] = $column;
             }
             break;
         default:
             throw new Exception("Unsupported driver");
     }
     return $columns;
 }
Beispiel #3
0
 /**
  * Returns the value of the given POST variable. If it does not exist,
  * return the default value (null by default).
  * 
  * If the method is not post, and the request content type is application/
  * x-www-form-urlencoded, the body will be parsed and the key/value pairs
  * will be put into the $_POST array.
  * 
  * The value can be cast to one of the PHP scalar values (string, integer,
  * float or boolean). Additionally, a "set" type can be used to return true
  * if the variable is defined irregardless of its value, and false if it is
  * not. This is userful when GET variables are used as flags to the request
  * (for example, key=value&sort_asc).
  *
  * @history
  * 2013.09.30:
  *   (AT)  Initial release
  *
  * @version 2013.09.30
  * @author (AT) Alberto Trevino, Brigham Young Univ. <*****@*****.**>
  * 
  * @param int $variable POST variable name
  * @param string $type Cast to the specified type (string|int|float|bool)
  * @param mixed $default Default value
  * @return mixed POST variable value
  */
 public function postValue($variable, $type = "string", $default = null)
 {
     # See if the header exists
     if (array_key_exists($variable, $_POST)) {
         # See what we will be returning
         switch ($type) {
             case "string":
             default:
                 return $_POST[$variable];
                 break;
             case "int":
                 return (int) $_POST[$variable];
                 break;
             case "float":
                 return (double) $_POST[$variable];
                 break;
             case "bool":
                 $value = $_POST[$variable];
                 Format::strToBool($value, true);
                 return $value;
                 break;
             case "set":
                 return true;
                 break;
         }
     } else {
         # Return the default value (always false for set type)
         if ($type == "set") {
             return false;
         } else {
             return $default;
         }
     }
 }
Beispiel #4
0
 /**
  * Returns a database connection to the named database.
  *
  * The information on the database is stored in individual Config files. The
  * place were these files are stored is configured via Config's static
  * properties.
  *
  * The config file should contain the following values:
  *
  *   dsn      - The PDO dsn connection string
  *   username - The username to use
  *   password - The password used for connection
  *   arc4     - Config file to ARC4 encryption parameters (optional)
  *
  * The username and passwords can be stored in either ARC4 encrypted form
  * (hex) or as obfuscated strings.
  *
  * The configuration files need to named using the following convention:
  *
  *   connection_name.environment.conf
  *
  * Because Unix filenames are case sensitive, the database name and the
  * environment will be converted to lowercase. Since Oracle schema names
  * are case-insensitive, and MySQL should be configured to be
  * case-insensitive, this should be of little difference. If case-
  * sensitivity is required, the DSN will preserve the casing of the schema
  * name.
  *
  * If no suitable environment is found, the method will do a final attempt
  * to find the connection information in a file named connection_name.conf.
  * If that's not present, it will do a final search for database.conf.
  *
  * The environment value can be any value. If no environment is specified,
  * the value will be taken from the ENVIRONMENT constant. If it is not set,
  * it will revert to "local." You may not specify "production" as the
  *  Production systems must have the ENVIRONMENT constant set.
  *
  * For best results, use the cougar-create-pdo-connection-file script
  * from a command prompt to generate your configuration files.
  *
  * @history
  * 2013.09.30:
  *   (AT)  Initial release
  * 2014.03.10:
  *   (AT)  Allow connection files to have a persistence flag
  *
  * @version 2014.03.10
  * @author (AT) Alberto Trevino, Brigham Young Univ. <*****@*****.**>
  *
  * @param string $name
  *   Database connection name
  * @param string $environment
  *   Environment to use (optional)
  * @return \Cougar\PDO\PDO Database connection
  * @throws \Cougar\Exceptions\Exception
  * @throws \Cougar\Exceptions\ConfigurationFileNotFoundException
  */
 public static function getConnection($name, $environment = null)
 {
     # Make sure we have a database name
     $name = strtolower($name);
     if (!$name) {
         throw new Exception("Database name is required");
     }
     # See if we have an environment
     if ($environment) {
         # Convert the environment to lowercase
         $environment = strtolower($environment);
         # Make sure we are not trying to set "production" as environment
         if ($environment == "production") {
             throw new Exception("You may not override the environment " . "\"production\"");
         }
     } else {
         # Grab the environment from the ENVIROMENT constant
         if (defined("ENVIRONMENT")) {
             $environment = strtolower(ENVIRONMENT);
         } else {
             $environment = "local";
         }
     }
     # Define the list of filenames to look for
     $filenames = array($name . "." . $environment . ".conf", $name . ".conf", "database.conf");
     # Try to load one of the configuration files
     $config = null;
     foreach ($filenames as $filename) {
         try {
             $config = new Config($filename);
             break;
         } catch (ConfigurationFileNotFoundException $e) {
             # Ignore file not found exceptions
         }
     }
     if (!$config) {
         throw new ConfigurationFileNotFoundException("Could not load configuration file for " . $name . " database for " . $environment);
     }
     # Get the values
     $dsn = $config->value("dsn");
     $orig_username = $config->value("username");
     $orig_password = $config->value("password");
     $persistent = $config->value("persistent");
     Format::strToBool($persistent);
     if (!$dsn) {
         throw new Exception("DSN is not declared in the configuration file");
     }
     # Try to decode the username and password via obfuscation
     $username = StringObfuscator::decode($orig_username);
     $password = StringObfuscator::decode($orig_password);
     if ($username == $orig_username && $password == $orig_password) {
         # Try to decode with Arc4
         $param_file = $config->value("arc4");
         if (!$param_file) {
             $param_file = $config->value("encryption");
         }
         if ($param_file) {
             Arc4::loadParameters($param_file);
         }
         $username = Arc4::decode($username);
         $password = Arc4::decode($password);
     }
     # See if we are establishing a persistent connection
     if ($persistent) {
         return new PDO($dsn, $username, $password, array(PDO::ATTR_PERSISTENT => true));
     } else {
         # Return the new database connection
         return new PDO($dsn, $username, $password);
     }
 }
Beispiel #5
0
 /**
  * @covers \Cougar\Util\Format::strToBool
  */
 public function testStrToBool()
 {
     $true_array = array("Yes", "True", "T", "true", "1", "ON");
     $false_array = array("No", "False", "F", "false", "0", "off");
     foreach ($true_array as $true) {
         Format::strToBool($true);
         $this->assertTrue($true);
     }
     foreach ($false_array as $false) {
         Format::strToBool($false);
         $this->assertFalse($false);
     }
     foreach ($true_array as $true) {
         Format::strToBool($true, true);
         $this->assertTrue($true);
     }
     foreach ($false_array as $false) {
         Format::strToBool($false, true);
         $this->assertFalse($false);
     }
     foreach (array("Some", "other", "string") as $other) {
         Format::strToBool($other, true);
         $this->assertFalse($other);
     }
     $true = $true_array;
     Format::strToBool($true);
     $this->assertEquals(array_fill(0, count($true), true), $true);
     $false = $false_array;
     Format::strToBool($false);
     $this->assertEquals(array_fill(0, count($false), false), $false);
     $jagged_array = array("false", "True", array("FALSE", "TRUE"));
     Format::strToBool($jagged_array);
     $this->assertEquals(array(false, true, array(false, true)), $jagged_array);
     $object = new \stdClass();
     $object->value1 = "true";
     $object->value2 = "False";
     $object->value3 = "Something else";
     Format::strToBool($object);
     $this->assertTrue($object->value1);
     $this->assertFalse($object->value2);
     $this->assertEquals("Something else", $object->value3);
     $embedded_object = new \stdClass();
     $embedded_object->value1 = "True";
     $embedded_object->value2 = "false";
     $embedded_object->object = new \stdClass();
     $embedded_object->object->value1 = "TRUE";
     $embedded_object->object->value2 = "FALSE";
     Format::strToBool($embedded_object);
     $this->assertTrue($embedded_object->value1);
     $this->assertFalse($embedded_object->value2);
     $this->assertTrue($embedded_object->object->value1);
     $this->assertFalse($embedded_object->object->value2);
 }