/** * 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 a file upload column * * Configuring a column to be a file upload column means that whenever * fActiveRecord::populate() is called for an fActiveRecord object, any * appropriately named file uploads (via `$_FILES`) will be moved into * the directory for this column. * * Setting the column to a file path will cause the specified file to * be copied into the directory for this column. * * @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/move to * @return void */ public static function configureFileUploadColumn($class, $column, $directory) { $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 file upload column.', $column, $data_type, join(', ', $valid_data_types)); } if (!is_object($directory)) { $directory = new fDirectory($directory); } if (!$directory->isWritable()) { throw new fEnvironmentException('The file upload directory, %s, is not writable', $directory->getPath()); } $camelized_column = fGrammar::camelize($column, TRUE); fORM::registerActiveRecordMethod($class, 'upload' . $camelized_column, self::upload); fORM::registerActiveRecordMethod($class, 'set' . $camelized_column, self::set); fORM::registerActiveRecordMethod($class, 'encode' . $camelized_column, self::encode); fORM::registerActiveRecordMethod($class, 'prepare' . $camelized_column, self::prepare); fORM::registerReflectCallback($class, self::reflect); fORM::registerInspectCallback($class, $column, self::inspect); fORM::registerReplicateCallback($class, $column, self::replicate); fORM::registerObjectifyCallback($class, $column, self::objectify); $only_once_hooks = array('post-begin::delete()' => self::begin, 'pre-commit::delete()' => self::delete, 'post-commit::delete()' => self::commit, 'post-rollback::delete()' => self::rollback, 'post::populate()' => self::populate, 'post-begin::store()' => self::begin, 'post-validate::store()' => self::moveFromTemp, 'pre-commit::store()' => self::deleteOld, 'post-commit::store()' => self::commit, 'post-rollback::store()' => self::rollback, 'post::validate()' => self::validate); foreach ($only_once_hooks as $hook => $callback) { if (!fORM::checkHookCallback($class, $hook, $callback)) { fORM::registerHookCallback($class, $hook, $callback); } } if (empty(self::$file_upload_columns[$class])) { self::$file_upload_columns[$class] = array(); } self::$file_upload_columns[$class][$column] = $directory; }
/** * 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 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; }
/** * Sets a column to be returned as an fNumber object from calls to `get{ColumnName}()` * * @param mixed $class The class name or instance of the class to set the column format * @param string $column The column to return as an fNumber object * @return void */ public static function configureNumberColumn($class, $column) { $class = fORM::getClass($class); $table = fORM::tablize($class); $schema = fORMSchema::retrieve($class); $data_type = $schema->getColumnInfo($table, $column, 'type'); $valid_data_types = array('integer', '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 number column.', $column, $data_type, join(', ', $valid_data_types)); } $camelized_column = fGrammar::camelize($column, TRUE); fORM::registerActiveRecordMethod($class, 'encode' . $camelized_column, self::encodeNumberColumn); fORM::registerActiveRecordMethod($class, 'prepare' . $camelized_column, self::prepareNumberColumn); fORM::registerReflectCallback($class, self::reflect); fORM::registerInspectCallback($class, $column, self::inspect); fORM::registerObjectifyCallback($class, $column, self::objectifyNumber); if (empty(self::$number_columns[$class])) { self::$number_columns[$class] = array(); } self::$number_columns[$class][$column] = TRUE; }