/** * Sets a column to be an image upload column * * This method works exactly the same as ::configureFileUploadColumn() * except that only image files are accepted. * * @param mixed $class The class name or instance of the class * @param string $column The column to set as a file upload column * @param fDirectory|string $directory The directory to upload to * @param string $image_type The image type to save the image as: `NULL`, `'gif'`, `'jpg'`, `'png'` * @return void */ public static function configureImageUploadColumn($class, $column, $directory, $image_type = NULL) { $valid_image_types = array(NULL, 'gif', 'jpg', 'png'); if (!in_array($image_type, $valid_image_types)) { $valid_image_types[0] = '{null}'; throw new fProgrammerException('The image type specified, %1$s, is not valid. Must be one of: %2$s.', $image_type, join(', ', $valid_image_types)); } self::configureFileUploadColumn($class, $column, $directory); $class = fORM::getClass($class); $camelized_column = fGrammar::camelize($column, TRUE); fORM::registerActiveRecordMethod($class, 'process' . $camelized_column, self::process); if (empty(self::$image_upload_columns[$class])) { self::$image_upload_columns[$class] = array(); } self::$image_upload_columns[$class][$column] = $image_type; self::addFUploadMethodCall($class, $column, 'setMimeTypes', array(array('image/gif', 'image/jpeg', 'image/pjpeg', 'image/png'), self::compose('The file uploaded is not an image'))); }
/** * Adds the method `toJSON()` to fActiveRecord and fRecordSet instances * * @return void */ public static function extend() { fORM::registerReflectCallback('*', self::reflect); fORM::registerActiveRecordMethod('*', 'toJSON', self::toJSON); fORM::registerRecordSetMethod('toJSON', self::toJSONRecordSet); }
/** * Sets a column to be an image upload column * * This method works exactly the same as ::configureFileUploadColumn() * except that only image files are accepted. * * To alter an image, including the file type, use ::addFImageMethodCall(). * * @param mixed $class The class name or instance of the class * @param string $column The column to set as a file upload column * @param fDirectory|string $directory The directory to upload to * @return void */ public static function configureImageUploadColumn($class, $column, $directory) { self::configureFileUploadColumn($class, $column, $directory); $class = fORM::getClass($class); $camelized_column = fGrammar::camelize($column, TRUE); fORM::registerActiveRecordMethod($class, 'process' . $camelized_column, self::process); if (empty(self::$image_upload_columns[$class])) { self::$image_upload_columns[$class] = array(); } self::$image_upload_columns[$class][$column] = TRUE; self::addFUploadMethodCall($class, $column, 'setMimeTypes', array(array('image/gif', 'image/jpeg', 'image/pjpeg', 'image/png'), self::compose('The file uploaded is not an image'))); }
/** * Sets a column to be formatted as an fMoney object * * @param mixed $class The class name or instance of the class to set the column format * @param string $column The column to format as an fMoney object * @param string $currency_column If specified, this column will store the currency of the fMoney object * @return void */ public static function configureMoneyColumn($class, $column, $currency_column = NULL) { $class = fORM::getClass($class); $table = fORM::tablize($class); $schema = fORMSchema::retrieve($class); $data_type = $schema->getColumnInfo($table, $column, 'type'); $valid_data_types = array('float'); if (!in_array($data_type, $valid_data_types)) { throw new fProgrammerException('The column specified, %1$s, is a %2$s column. Must be %3$s to be set as a money column.', $column, $data_type, join(', ', $valid_data_types)); } if ($currency_column !== NULL) { $currency_column_data_type = $schema->getColumnInfo($table, $currency_column, 'type'); $valid_currency_column_data_types = array('varchar', 'char', 'text'); if (!in_array($currency_column_data_type, $valid_currency_column_data_types)) { throw new fProgrammerException('The currency column specified, %1$s, is a %2$s column. Must be %3$s to be set as a currency column.', $currency_column, $currency_column_data_type, join(', ', $valid_currency_column_data_types)); } } $camelized_column = fGrammar::camelize($column, TRUE); fORM::registerActiveRecordMethod($class, 'encode' . $camelized_column, self::encodeMoneyColumn); fORM::registerActiveRecordMethod($class, 'prepare' . $camelized_column, self::prepareMoneyColumn); if (!fORM::checkHookCallback($class, 'post::validate()', self::validateMoneyColumns)) { fORM::registerHookCallback($class, 'post::validate()', self::validateMoneyColumns); } fORM::registerReflectCallback($class, self::reflect); fORM::registerInspectCallback($class, $column, self::inspect); $value = FALSE; if ($currency_column) { $value = $currency_column; if (empty(self::$currency_columns[$class])) { self::$currency_columns[$class] = array(); } self::$currency_columns[$class][$currency_column] = $column; if (!fORM::checkHookCallback($class, 'post::loadFromResult()', self::makeMoneyObjects)) { fORM::registerHookCallback($class, 'post::loadFromResult()', self::makeMoneyObjects); } if (!fORM::checkHookCallback($class, 'pre::validate()', self::makeMoneyObjects)) { fORM::registerHookCallback($class, 'pre::validate()', self::makeMoneyObjects); } fORM::registerActiveRecordMethod($class, 'set' . $camelized_column, self::setMoneyColumn); fORM::registerActiveRecordMethod($class, 'set' . fGrammar::camelize($currency_column, TRUE), self::setCurrencyColumn); } else { fORM::registerObjectifyCallback($class, $column, self::objectifyMoney); } if (empty(self::$money_columns[$class])) { self::$money_columns[$class] = array(); } self::$money_columns[$class][$column] = $value; }
/** * Sets a timestamp column to store the timezone in another column * * Since not all databases support timezone information in timestamp * columns, this method allows storing the timezone in another columns. * When the timestamp and timezone are retrieved from the database, they * will be automatically combined together into an fTimestamp object. * * @param mixed $class The class name or instance of the class to set the column format * @param string $timestamp_column The timestamp column to store the timezone for * @param string $timezone_column The column to store the timezone in * @return void */ public static function configureTimezoneColumn($class, $timestamp_column, $timezone_column) { $class = fORM::getClass($class); $table = fORM::tablize($class); $schema = fORMSchema::retrieve($class); $timestamp_data_type = $schema->getColumnInfo($table, $timestamp_column, 'type'); if ($timestamp_data_type != 'timestamp') { throw new fProgrammerException('The timestamp column specified, %1$s, is a %2$s column. Must be a %3$s to have a related timezone column.', $timestamp_column, $data_type, 'timestamp'); } $timezone_column_data_type = $schema->getColumnInfo($table, $timezone_column, 'type'); $valid_timezone_column_data_types = array('varchar', 'char', 'text'); if (!in_array($timezone_column_data_type, $valid_timezone_column_data_types)) { throw new fProgrammerException('The timezone column specified, %1$s, is a %2$s column. Must be %3$s to be set as a timezone column.', $timezone_column, $timezone_column_data_type, join(', ', $valid_timezone_column_data_types)); } if (!fORM::checkHookCallback($class, 'post::validate()', self::validateTimezoneColumns)) { fORM::registerHookCallback($class, 'post::validate()', self::validateTimezoneColumns); } if (!fORM::checkHookCallback($class, 'post::loadFromResult()', self::makeTimestampObjects)) { fORM::registerHookCallback($class, 'post::loadFromResult()', self::makeTimestampObjects); } if (!fORM::checkHookCallback($class, 'pre::validate()', self::makeTimestampObjects)) { fORM::registerHookCallback($class, 'pre::validate()', self::makeTimestampObjects); } fORM::registerInspectCallback($class, $timezone_column, self::inspect); fORM::registerActiveRecordMethod($class, 'set' . fGrammar::camelize($timestamp_column, TRUE), self::setTimestampColumn); fORM::registerActiveRecordMethod($class, 'set' . fGrammar::camelize($timezone_column, TRUE), self::setTimezoneColumn); if (empty(self::$timestamp_columns[$class])) { self::$timestamp_columns[$class] = array(); } self::$timestamp_columns[$class][$timestamp_column] = $timezone_column; if (empty(self::$timezone_columns[$class])) { self::$timezone_columns[$class] = array(); } self::$timezone_columns[$class][$timezone_column] = $timestamp_column; }
/** * Sets a column to be an ordering column * * There can only be one ordering column per class/table and it must be * part of a single or multi-column `UNIQUE` constraint. * * @param mixed $class The class name or instance of the class * @param string $column The column to set as an ordering column * @return void */ public static function configureOrderingColumn($class, $column) { $class = fORM::getClass($class); $table = fORM::tablize($class); $schema = fORMSchema::retrieve($class); $info = $schema->getColumnInfo($table, $column); $unique_keys = $schema->getKeys($table, 'unique'); if ($info['type'] != 'integer') { throw new fProgrammerException('The column specified, %1$s, is a %2$s column. It must be an integer column to be set as an ordering column.', $column, $data_type); } if ($info['min_value'] && $info['min_value']->eq(0)) { throw new fProgrammerException('The column specified, %1$s, does not allow for negative values. Please adjust the data type to an integer type that allows for negative values.', $column); } $found = FALSE; foreach ($unique_keys as $unique_key) { settype($unique_key, 'array'); if (in_array($column, $unique_key)) { $other_columns = array_diff($unique_key, array($column)); $found = TRUE; break; } } if (!$found) { throw new fProgrammerException('The column specified, %s, does not appear to be part of a unique key. It must be part of a unique key to be set as an ordering column.', $column); } if (!fORM::checkHookCallback($class, 'post::validate()', self::validate)) { fORM::registerHookCallback($class, 'post::validate()', self::validate); } if (!fORM::checkHookCallback($class, 'post-validate::store()', self::reorder)) { fORM::registerHookCallback($class, 'post-validate::store()', self::reorder); } if (!fORM::checkHookCallback($class, 'pre-commit::delete()', self::delete)) { fORM::registerHookCallback($class, 'pre-commit::delete()', self::delete); } fORM::registerReflectCallback($class, self::reflect); fORM::registerActiveRecordMethod($class, 'inspect' . fGrammar::camelize($column, TRUE), self::inspect); self::$ordering_columns[$class][$column] = $other_columns; }
/** * Sets a column to be an ordering column * * There can only be one ordering column per class/table and it must be * part of a single or multi-column `UNIQUE` constraint. * * @param mixed $class The class name or instance of the class * @param string $column The column to set as an ordering column * @return void */ public static function configureOrderingColumn($class, $column) { $class = fORM::getClass($class); $table = fORM::tablize($class); $data_type = fORMSchema::retrieve()->getColumnInfo($table, $column, 'type'); $unique_keys = fORMSchema::retrieve()->getKeys($table, 'unique'); if ($data_type != 'integer') { throw new fProgrammerException('The column specified, %1$s, is a %2$s column. It must be an integer column to be set as an ordering column.', $column, $data_type); } $found = FALSE; foreach ($unique_keys as $unique_key) { settype($unique_key, 'array'); if (in_array($column, $unique_key)) { $other_columns = array_diff($unique_key, array($column)); $found = TRUE; break; } } if (!$found) { throw new fProgrammerException('The column specified, %s, does not appear to be part of a unique key. It must be part of a unique key to be set as an ordering column.', $column); } fORM::registerHookCallback($class, 'post::validate()', self::validate); fORM::registerHookCallback($class, 'post-validate::store()', self::reorder); fORM::registerHookCallback($class, 'pre-commit::delete()', self::delete); fORM::registerReflectCallback($class, self::reflect); fORM::registerActiveRecordMethod($class, 'inspect' . fGrammar::camelize($column, TRUE), self::inspect); // Ensure we only ever have one ordering column by overwriting self::$ordering_columns[$class]['column'] = $column; self::$ordering_columns[$class]['other_columns'] = $other_columns; }
public function setUp() { if (defined('SKIPPING')) { $this->markTestSkipped(); } fORMDatabase::attach(self::$db); fORMSchema::attach(self::$schema); if (defined('MAP_TABLES')) { fORM::mapClassToTable('User', 'user'); fORM::mapClassToTable('Group', 'group'); fORM::mapClassToTable('Artist', 'popular_artists'); fORM::mapClassToTable('Album', 'records'); } fORM::registerActiveRecordMethod('User', 'hasChanged', 'changed'); }
/** * Sets a column to be a random string column - a random string will be generated when the record is saved * * @param mixed $class The class name or instance of the class * @param string $column The column to set as a random column * @param string $type The type of random string, must be one of: `'alphanumeric'`, `'alpha'`, `'numeric'`, `'hexadecimal'` * @param integer $length The length of the random string * @return void */ public static function configureRandomColumn($class, $column, $type, $length) { $class = fORM::getClass($class); $table = fORM::tablize($class); $schema = fORMSchema::retrieve($class); $data_type = $schema->getColumnInfo($table, $column, 'type'); $valid_data_types = array('varchar', 'char', 'text'); if (!in_array($data_type, $valid_data_types)) { throw new fProgrammerException('The column specified, %1$s, is a %2$s column. Must be one of %3$s to be set as a random string column.', $column, $data_type, join(', ', $valid_data_types)); } $valid_types = array('alphanumeric', 'alpha', 'numeric', 'hexadecimal'); if (!in_array($type, $valid_types)) { throw new fProgrammerException('The type specified, %1$s, is an invalid type. Must be one of: %2$s.', $type, join(', ', $valid_types)); } if (!is_numeric($length) || $length < 1) { throw new fProgrammerException('The length specified, %s, needs to be an integer greater than zero.', $length); } fORM::registerActiveRecordMethod($class, 'generate' . fGrammar::camelize($column, TRUE), self::generate); if (!fORM::checkHookCallback($class, 'pre::validate()', self::setRandomStrings)) { fORM::registerHookCallback($class, 'pre::validate()', self::setRandomStrings); } fORM::registerInspectCallback($class, $column, self::inspect); if (empty(self::$random_columns[$class])) { self::$random_columns[$class] = array(); } self::$random_columns[$class][$column] = array('type' => $type, 'length' => (int) $length); }