/**
* Returns an array of script obtained from a directory
*
* @param string $dir
* @param string $parent
* @return array
*/
public static function getScriptFromDir($dir, $parent = '')
{
$scripts = array();
foreach (new DirectoryIterator($dir) as $file) {
if ($file->isDot() || substr($file->getFilename(), 0, 1) == '.') {
continue;
}
$filename = $file->getFilename();
if (strpos($filename, '.') !== false) {
$filename = substr($filename, 0, strrpos($filename, '.'));
}
$className = trim($parent . '_' . $filename, '_');
if ($file->isDir()) {
$scripts = array_merge($scripts, self::getScriptFromDir($file->getPathname(), $className));
continue;
}
require_once $file->getPathname();
if (!class_exists($className, false)) {
continue;
}
$builder = Atomik_Model_Builder_Factory::get($className);
$scripts[] = new Atomik_Db_Script_Model($builder);
}
return $scripts;
}
public static function getModelBuilder($name)
{
if (!class_exists($name, false)) {
$modelFile = Atomik::path($name . '.php', DbPlugin::$config['model_dirs']);
include $modelFile;
}
return Atomik_Model_Builder_Factory::get($name);
}
/**
* Constructor
*
* @param string|Atomik_Model_Builder|Atomik_Model $object
*/
public function __construct($object, $optionPrefix = 'form-')
{
$this->_optionPrefix = $optionPrefix;
$this->setBuilder(Atomik_Model_Builder_Factory::get($object));
if ($object instanceof Atomik_Model) {
$this->setModel($object);
}
$this->setData(array_merge($_POST, $_FILES));
}
/**
* Returns the builder from a db query
*
* @param Atomik_Db_Query $query
* @return Atomik_Model_Builder
*/
public static function getBuilderFromQuery(Atomik_Db_Query $query)
{
$from = $query->getInfo('from');
if (count($from) > 1) {
require_once 'Atomik/Model/Manager/Exception.php';
throw new Atomik_Model_Manager_Exception('Only one table can be used in the FROM clause with Atomik_Model_Manager');
}
$tableName = substr($from[0]['table'], strlen($query->getInstance()->getTablePrefix())); // remove the table prefix
return Atomik_Model_Builder_Factory::getFromTableName($tableName);
}
/**
* Sets which model to query
*
* @param string|Atomik_Model_Builder $model
* @return Atomik_Model_Query
*/
public function from($model)
{
$this->_builder = Atomik_Model_Builder_Factory::get($model);
$this->setInstance($this->_builder->getManager()->getDbInstance());
return parent::from($this->_builder->tableName);
}
/**
* Inits the builder
*/
protected function _initBuilder()
{
$this->_builder = Atomik_Model_Builder_Factory::get($this);
}
/**
* Sets the parent model
*
* @param string|Atomik_Model_Builder $parentModel
*/
public function setParentModel($parentModel)
{
$parent = Atomik_Model_Builder_Factory::get($parentModel);
$type = $parent->getOption('inheritance', 'abstract');
switch($type) {
case 'none':
return;
case 'abstract':
$this->_fields = array_merge($parent->getFields(), $this->_fields);
$this->_options = array_merge($parent->getOptions(), $this->_options);
foreach ($parent->getBehaviourBroker()->getBehaviours() as $behaviour) {
$this->_behaviourBroker->addBehaviour(clone $behaviour);
}
foreach ($parent->getReferences() as $ref) {
$this->addReference(clone $ref);
}
foreach ($parent->getLinks() as $link) {
$this->addLink(clone $link);
}
break;
case 'reference':
$ref = new Atomik_Model_Builder_Reference('parent', Atomik_Model_Builder_Reference::HAS_PARENT);
$ref->target = $parent;
$ref->targetField = $parent->getPrimaryKeyField()->name;
$ref->sourceField = $ref->target . '_' . $ref->targetField;
$this->addReference($ref);
break;
}
$this->_parentModelBuilder = $parent;
$this->_inheritanceType = $type;
}
/**
* Returns reference fields depending on the type of reference
*
* @param Atomik_Model_Builder $builder
* @param string $targetName
* @param string $type
* @return array array(sourceField, targetField)
*/
public static function getReferenceFields(Atomik_Model_Builder $builder, $targetName, $type)
{
$targetBuilder = self::_getBaseBuilder($targetName);
if ($type == Atomik_Model_Builder_Reference::HAS_PARENT) {
// targetModel.targetPrimaryKey = sourceModel.targetModel_targetPrimaryKey
$targetField = $targetBuilder->getPrimaryKeyField()->name;
$sourceField = strtolower($targetName) . '_' . $targetField;
} else if ($type == Atomik_Model_Builder_Reference::HAS_ONE) {
// targetModel.sourceModel_sourcePrimaryKey = sourceModel.sourcePrimaryKey
$sourceField = $builder->getPrimaryKeyField()->name;
$targetField = strtolower($builder->name) . '_' . $sourceField;
} else {
$targetBuilder = Atomik_Model_Builder_Factory::get($targetName);
// HAS_MANY
// searching through the target model references for one pointing back to this model
$parentRefs = $targetBuilder->getReferences();
$found = false;
foreach ($parentRefs as $parentRef) {
if ($parentRef->isHasParent() && $parentRef->isTarget($builder->name)) {
$sourceField = $parentRef->targetField;
$targetField = $parentRef->sourceField;
$found = true;
break;
}
}
if (!$found) {
require_once 'Atomik/Model/Builder/Exception.php';
throw new Atomik_Model_Builder_Exception('No back reference in ' . $targetName . ' for ' . $builder->name);
}
}
return array($sourceField, $targetField);
}
/**
* Empties the cache
*/
public static function invalidateCache()
{
self::$_cache = array();
}
/**
* Returns the builder of the target
*
* @return Atomik_Model_Builder
*/
public function getTargetBuilder()
{
return Atomik_Model_Builder_Factory::get($this->target);
}
/**
* Finds one model
*
* @param string|Atomik_Model_Builder $builder
* @param string $primaryKey
* @return Atomik_Model
*/
public static function find($builder, $primaryKey)
{
$builder = Atomik_Model_Builder_Factory::get($builder);
$where = array($builder->getPrimaryKeyField()->name => $primaryKey);
return self::findOne($builder, $where);
}
