From b68832a00307b23fc402b501166d5ecc89447785 Mon Sep 17 00:00:00 2001 From: Silvio Date: Wed, 28 Jul 2010 12:08:01 -0300 Subject: Initial import --- lib/sfIsisImporter.class.php | 333 ++++++++++++++++++++++++++++++++++++++ lib/sfIsisImporterBase.class.php | 211 ++++++++++++++++++++++++ lib/task/isisImportTask.class.php | 45 ++++++ 3 files changed, 589 insertions(+) create mode 100644 lib/sfIsisImporter.class.php create mode 100644 lib/sfIsisImporterBase.class.php create mode 100644 lib/task/isisImportTask.class.php (limited to 'lib') diff --git a/lib/sfIsisImporter.class.php b/lib/sfIsisImporter.class.php new file mode 100644 index 0000000..9233f64 --- /dev/null +++ b/lib/sfIsisImporter.class.php @@ -0,0 +1,333 @@ +caller = $caller; + $this->section = $section; + + foreach ($this->databases() as $database) + { + // Open database. + $this->log('Starting mass import procedure for config '. $database .'.'); + $this->open($this->config($database)); + + // Determine base model and max entries. + $base_model = $this->format['db']['base_model']; + $this->entries = ($entries != NULL && $entries <= $this->entries) ? $entries : $this->entries; + + if ($base_model) { + for ($entry = 1; $entry <= $this->entries; $entry++) + { + $this->addEntry($base_model, $entry); + $this->progress($entry); + } + } + + $this->afterImport(); + } + } + + /** + * Add a single entry from the database. + * + * @param string $base_model Model to use + * @param int $entry Entry number + * @todo Warn if repetition occurs for non-repeatable fields + * @todo Check if content already exist if a primary key is specified + */ + public function addEntry($base_model, $entry) + { + // Get data and setup the model. + $this->read($entry); + $model = new $base_model(); + $this->setBaseModelId($model); + + $this->log("Importing $base_model $entry..."); + + // Dispatch to custom import procedures. + foreach (new IsisMethodIterator($this) as $method => $field) + { + $this->{$method}($model, $field); + } + + $model->save(); + } + + /** + * Set the primary key for the model by getting it or saving the model. + * + * @param object $model Base model + */ + public function setBaseModelId(&$model) + { + $id = $this->getBaseModelId($model); + + if ($id) + { + $model->id = $id; + } + else + { + $model->save(); + } + } + + /** + * Get the primary key for the base model. + * + * @param object $model Base model + * @return int Base model id + * @todo Write and test + */ + public function getBaseModelId(&$model) + { + return false; + } + + /** + * Import a single field into a model. + * + * @param object $model Model + * @param array $field Field data from ISIS database schema + * @param int $row Row number + */ + public function addField(&$model, $field, $row = 0) { + $value = $this->filterBrackets($this->getMainItem($field, $row)); + + if ($value != null) + { + $map = $this->getMap($field); + $model->{$map}($value); + } + } + + /** + * Import a single subfield into a model. + * + * @param object $model Model + * @param array $field Field data from ISIS database schema + * @param string $subfield Subfield name + * @param int $row Row number + */ + public function addSubfield(&$model, $field, $subfield, $row = 0) { + $value = $this->filterBrackets($this->getSubfield($field, $subfield, $row)); + + if ($value != null) + { + $map = $this->getMap($field, $subfield); + $model->{$map}($value); + } + } + + /** + * Import single values into the model. + * + * Currently undefined mappings for a field/subfield + * are not saved as we would need to make sure a corresponding + * field exists in the model. This prevents the map + * configurations like $map = array('type' => 'value'); to work. + * + * As we are importing single values, here we don't care with + * row numbers as we assume that just the first row should be + * imported. + * + * @param object $model Model object + * @param array $field Field data + */ + public function importValues(&$model, array $field) + { + if ($this->fieldHasMap($field)) + { + $this->addField($model, $field); + } + + foreach ($this->getSubfieldList($field) as $subfield) + { + if ($this->subfieldHasMap($field, $subfield)) + { + $this->addSubfield($model, $field, $subfield); + } + } + } + + /** + * Add a new entity into the database if needed, returning + * the corresponding object. + * + * @param string $name Genre name + * @return Genre Genre data + */ + public function addEntity($entity, $name) + { + $name = $this->entityName($name); + $data = Doctrine_Core::getTable($entity)->findOneByName($name); + + if (!$data) + { + $this->log("Adding new $entity $name."); + $data = new $entity(); + $data->name = $name; + $data->save(); + } + + return $data; + } + + /** + * Import one to one data. + * + * @param object $model Model + * @param array $field Field data from ISIS database schema + * @param string $relation Relation name + */ + public function addOneToOne(&$model, array $field, $relation) + { + foreach (new IsisRowIterator($this, $field) as $row) + { + $data = new $relation(); + + foreach ($this->getSubfieldList($field) as $subfield) + { + $this->addSubfield($data, $field, $subfield, $row); + } + + $data->save(); + $key = sfInflector::underscore($relation) .'_id'; + $model->$key = $relation->id; + } + } + + /** + * Import many to many data. + * + * @param object $model Model + * @param array $values Values to be added + * @param string $relation Relation name + */ + public function addManyToMany(&$model, array $values, $relation) { + $method = 'add'. $relation; + + foreach ($values as $value) + { + // Populate related data. + if (is_callable(array($this, $method))) + { + $data = $this->{$method}($value); + } + else + { + $data = $this->addEntity($relation, $value); + } + + // Get model and relation names and id fields. + $model_id = $this->getModelId($model); + $relation_id = $this->getRelationId($relation); + $model_relation = $this->getModelRelation($model, $relation); + + // Make the relation. + $model_data = new $model_relation(); + $model_data->{$model_id} = $model->id; + $model_data->{$relation_id} = $data->id; + $model_data->save(); + } + } + + /** + * Import one to one data. + * + * @param object $model Model + * @param string $relation Relation name + * @return object Relation model object + */ + public function addOneToMany(&$model, $relation) + { + $model_id = $this->getModelId($model); + $data = new $relation(); + $data->{$model_id} = $model->id; + $data->save(); + return $data; + } + + /** + * Add simple entities data into the model. + * + * @param object $model Model + * @param array $field Field data from ISIS database schema + */ + public function addOneToManyEntities(&$model, array $field, $entity, $key = 'name') + { + foreach (new IsisMainItemIterator($this, $field) as $row => $value) + { + $this->log("Entity: $entity; Value: $value", 'debug'); + $data = $this->addOneToMany($model, $entity); + $data->{$key} = $value; + $data->save(); + } + } + + /** + * Add field values in a many-to-many relation. + * + * @param object $model Model + * @param array $field Field data from ISIS database schema + * @param string $relation Relation name + */ + public function addManyToManyField(&$model, array $field, $relation) + { + foreach (new IsisMainItemIterator($this, $field) as $value) + { + $this->addManyToMany($model, $this->explodeBrackets($value), $relation); + } + } + + /** + * Add an element into the database if needed, returning + * the resulting object. + * + * @param string $entity Entity name + * @param string $value Entity value + * @return object Entity data + */ + public function newOrExisting($entity, $value) + { + // Check for a null value. + if ($value == null) + { + $this->log("Null element value for $entity.", 'debug'); + return; + } + + // Get name. + $name = $this->parseName($value); + + // Get existing element. + $element = call_user_func(array($entity, 'getByName'), $name); + + // Create new element if needed. + if (!$element) + { + $this->log("Adding new $entity $value."); + $element = call_user_func(array($entity, 'addByName'), $name); + } + + return $element; + } +} diff --git a/lib/sfIsisImporterBase.class.php b/lib/sfIsisImporterBase.class.php new file mode 100644 index 0000000..fac694a --- /dev/null +++ b/lib/sfIsisImporterBase.class.php @@ -0,0 +1,211 @@ +loglevel = $loglevel; + } + + /** + * Create an ISIS configuration for a given database. + * + * @param string $database Database name + * @return array Basic configuration + */ + public function config($database) + { + // Default cinisis config file. + $config = $this->isis->file(); + + if (file_exists($config)) + { + $this->log("Using Cinisis config file $config."); + $config = sfYaml::load($config); + } + else { + // Default configuration. + $this->log("Cinisis config file not found, building configuration."); + $config = array( + 'implementation' => 'BiblioIsis', + ); + } + + $config['database'] = $database; + return $config; + } + + /** + * List available ISIS databases. + * + * @return array Available databases + */ + public function databases() + { + $files = glob(sfConfig::get('sf_lib_dir') .'/cinisis/schemas/*.yaml'); + foreach ($files as $file) + { + $databases[] = basename($file, '.yaml'); + } + + return $databases; + } + + /** + * Log dispatcher. + * + * @param string $message Log message + * @param string $level Log level + */ + public function log($message, $level = 'info') + { + // Available log levels ordered by verbosity. + $levels = array_flip(array('fatal', 'info', 'warn', 'error', 'debug')); + + // Log level checking. + if (array_search($level, $levels) === FALSE) + { + $this->log("Invalid log level $level.", 'error'); + return; + } + elseif ($levels[$level] > $levels[$this->loglevel]) + { + return; + } + + // Dispatch. + if ($this->section == 'action') + { + $this->caller->logMessage($message, $level); + } + else + { + $this->caller->logSection('isisImporter', "[$level] $message"); + } + } + + /** + * Progress notifier. + * + * @param int $n Row number + */ + public function progress($n) + { + $this->processed = $n; + + if ($this->section == 'action') + { + $this->caller->output .= "Saved item $n\n"; + } + else + { + // Progress bar is just shown if loglevel is 'fatal'. + if ($this->loglevel == 'fatal') + { + $this->caller->progressBar($n, $this->entries); + } + } + } + + /** + * Guess a method name from a type. + * + * @param string $type Mapping type + * @return string Method name + */ + static function methodName($type) + { + return 'import'. ucfirst($type); + } + + /** + * Get the model foreign table id. + * + * @param object $model Model + * @return string Model table id + */ + static function getModelId($model) { + return sfInflector::underscore(get_class($model)) .'_id'; + } + + /** + * Get the relation foreign table id. + * + * @param string $model Relation name + * @return string Relation table id + */ + static function getRelationId($relation) { + return sfInflector::underscore($relation) .'_id'; + } + + /** + * Get the model and relation tablename. + * + * @param object $model Model + * @param string $model Relation name + * @return string Relation table name + */ + static function getModelRelation($model, $relation) + { + return sfInflector::camelize(self::getModelName($model)) . sfInflector::camelize($relation); + } + + /** + * Get the entity name from a subfield. + * + * @param string $subfield Subfield name + * @return string Genre name + */ + static function entityName($subfield) + { + return ucfirst($subfield); + } + + /** + * Get the model name. + * + * @param object $model Model + * @return string Model name + */ + static function getModelName($model) + { + return get_class($model); + } + + /** + * After import procedure. + */ + public function afterImport() { + // Output ISIS log messages. + if (is_array($this->isis->db->log)) + { + foreach ($this->isis->db->log as $log) + { + $this->log("[isis] $log"); + } + } + + $this->log("Finished mass import procedure."); + $this->log("Total entries processed: $this->processed."); + } +} diff --git a/lib/task/isisImportTask.class.php b/lib/task/isisImportTask.class.php new file mode 100644 index 0000000..b6d70af --- /dev/null +++ b/lib/task/isisImportTask.class.php @@ -0,0 +1,45 @@ +addArgument('rows', sfCommandArgument::OPTIONAL, 'Optional number of rows to process'); + $this->addOptions(array( + new sfCommandOption('application', null, sfCommandOption::PARAMETER_REQUIRED, 'The application name'), + new sfCommandOption('env', null, sfCommandOption::PARAMETER_REQUIRED, 'The environment', 'dev'), + new sfCommandOption('connection', null, sfCommandOption::PARAMETER_REQUIRED, 'The connection name', 'doctrine'), + new sfCommandOption('loglevel', 'l', sfCommandOption::PARAMETER_REQUIRED, 'Log level', 'info'), + )); + + $this->namespace = 'isis'; + $this->name = 'import'; + $this->briefDescription = 'Imports an ISIS database into the application'; + $this->detailedDescription = <<configuration); + $connection = $databaseManager->getDatabase($options['connection'])->getConnection(); + + // Initialize an IsisConnector. + $isis = new CineImporter($options['loglevel']); + + // Error handling. + if ($isis == FALSE) + { + $this->logSection('isis', 'Error opening ISIS database.'); + return FALSE; + } + + // Mass ISIS import. + $isis->massImport($this, 'task', $arguments['rows']); + } +} -- cgit v1.2.3