keeko\tools\services\ModelService

Complexity

Total Complexity

51

Size/Duplication

Total Lines	340
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	20

Test Coverage

Coverage

70.8%

Importance

Changes	14
Bugs	1	Features	1

18 Methods

Rating	Name	Duplication	Size	Complexity
B	getSchema()	0	28	6
A	isCoreSchema()	0	3	1
A	hasSchema()	0	4	3
A	getDatabase()	0	9	2
A	getTableName()	0	8	2
A	getModelNames()	0	9	2
B	getModels()	0	16	5
A	getModel()	0	7	1
B	getPackageModelNames()	0	23	6
A	hasModel()	0	3	1
B	getModelName()	0	13	5
A	getModelNameByAction()	0	8	2
A	getFullModelObjectName()	0	8	1
A	getOperationByAction()	0	8	2
A	isModelAction()	0	4	1
A	isCrudAction()	0	5	1
C	getRelationships()	0	46	9
A	getRelationship()	0	4	1

<?php
namespace keeko\tools\services;

use keeko\framework\schema\ActionSchema;
use keeko\framework\schema\PackageSchema;
use phootwork\collection\ArrayList;
use phootwork\lang\Text;
use Propel\Generator\Model\Database;
use Propel\Generator\Model\Table;
use Propel\Generator\Util\QuickBuilder;
use phootwork\collection\Set;
use keeko\tools\model\Relationships;
use keeko\tools\model\Relationship;
use keeko\tools\model\ManyRelationship;
use phootwork\collection\Map;

class ModelService extends AbstractService {

	private $models = null;
	private $schema = null;
	
	/** @var Database */
	private $database = null;
	
	private $relationships = null;

	/**
	 * Returns the propel schema. The three locations, where the schema is looked up in:
	 *
	 * 1. --schema option (if available)
	 * 2. res/database/schema.xml
	 * 3. <keeko/core>/res/database/schema.xml
	 *
	 * @throws \RuntimeException
	 * @return string the path to the schema
	 */
	public function getSchema() {
		$input = $this->io->getInput();
		if ($this->schema === null) {
			$workDir = $this->service->getProject()->getRootPath();
			$schema = null;
			$schemas = [
				$input->hasOption('schema') ? $input->getOption('schema') : '',
				$workDir . '/database/schema.xml',
				$workDir . '/res/database/schema.xml',
				$workDir . '/vendor/keeko/core/database/schema.xml',
				$workDir . '/vendor/keeko/core/res/database/schema.xml'
			];
			foreach ($schemas as $path) {
				if (file_exists($path)) {
					$schema = $path;
					break;
				}
			}
			$this->schema = $schema;
				
			if ($schema === null) {
				$locations = implode(', ', $schemas);
				throw new \RuntimeException(sprintf('Can\'t find schema in these locations: %s', $locations));
			}
		}

		return $this->schema;
	}
	
	public function isCoreSchema() {
		return strpos($this->getSchema(), 'core') !== false;
	}
	
	public function hasSchema() {
		$vendorName = $this->packageService->getPackage()->getVendor();
		return $this->getSchema() !== null && ($this->isCoreSchema() ? $vendorName == 'keeko' : true);
	}
	
	/**
	 * Returns the propel database
	 *
	 * @return Database
	 */
	public function getDatabase() {
		if ($this->database === null) {
			$builder = new QuickBuilder();
			$builder->setSchema(file_get_contents($this->getSchema()));
			$this->database = $builder->getDatabase();
		}
	
		return $this->database;
	}
	
	/**
	 * Returns the tableName for a given name
	 *
	 * @param String $name tableName or modelName
	 * @return String tableName
	 */
	public function getTableName($name) {
		$db = $this->getDatabase();
		if (!Text::create($name)->startsWith($db->getTablePrefix())) {
			$name = $db->getTablePrefix() . $name;
		}
	
		return $name;
	}
	
	/**
	 * Returns all model names
	 *
	 * @return String[] an array of modelName
	 */
	public function getModelNames() {
		$names = [];
		$database = $this->getDatabase();
		foreach ($database->getTables() as $table) {
			$names[] = $table->getOriginCommonName();
		}
	
		return $names;
	}
	
	/**
	 * Returns the propel models from the database, where table namespace matches package namespace
	 *
	 * @return ArrayList<Table>
	 */
	public function getModels() {
		if ($this->models === null) {
			$namespace = $this->packageService->getNamespace() . '\\model';
			$propel = $this->getDatabase();
	
			$this->models = new ArrayList();
	
			foreach ($propel->getTables() as $table) {
				if (!$table->isCrossRef() && $table->getNamespace() == $namespace) {
					$this->models->add($table);
				}
			}
		}
	
		return $this->models;
	}

	/**
	 * Returns the model for the given name
	 *
	 * @param String $name modelName or tableName
	 * @return Table
	 */
	public function getModel($name) {
		$tableName = $this->getTableName($name);
		$db = $this->getDatabase();
		$table = $db->getTable($tableName);
	
		return $table;
	}
	
	/**
	 * Returns the model names for a given package
	 * 
	 * @param PackageSchema $package a package to search models for, if omitted global package is used
	 * @return array array with string of model names
	 */
	public function getPackageModelNames(PackageSchema $package = null) {
		if ($package === null) {
			$package = $this->packageService->getPackage();
		}
		
		$models = [];
		// if this is a core-module, find the related model
		if ($package->getVendor() == 'keeko' && $this->isCoreSchema()) {
			$model = $package->getName();
			if ($this->hasModel($model)) {
				$models [] = $model;
			}
		}
		
		// anyway, generate all
		else {
			foreach ($this->getModels() as $model) {
				$models [] = $model->getOriginCommonName();
			}
		}
		
		return $models;
	}
	
	/**
	 * Checks whether the given model exists
	 *
	 * @param String $name tableName or modelName
	 * @return boolean
	 */
	public function hasModel($name) {
		return $this->getDatabase()->hasTable($this->getTableName($name), true);
	}

	/**
	 * Retrieves the model name for the given package in two steps:
	 * 
	 * 1. Check if it is passed as cli parameter
	 * 2. Retrieve it from the package name
	 *
	 * @return String
	 */
	public function getModelName() {
		$input = $this->io->getInput();
		$modelName = $input->hasOption('model') ? $input->getOption('model') : null;
		if ($modelName === null && $this->isCoreSchema()) {
			$package = $this->service->getPackageService()->getPackage();
			$packageName = $package->getName();

			if ($this->hasModel($packageName)) {
				$modelName = $packageName;
			}
		}
		return $modelName;
	}
	
	/**
	 * Parses the model name from a given action name
	 *
	 * @param ActionSchema $action
	 * @return String modelName
	 */
	public function getModelNameByAction(ActionSchema $action) {
		$actionName = $action->getName();
		$modelName = null;
		if (($pos = strpos($actionName, '-')) !== false) {
			$modelName = substr($actionName, 0, $pos);
		}
		return $modelName;
	}

	/**
	 * Returns the full model object name, including namespace
	 * 
	 * @param ActionSchema $action
	 * @return String fullModelObjectName
	 */
	public function getFullModelObjectName(ActionSchema $action) {
		$database = $this->getDatabase();
		$modelName = $this->getModelNameByAction($action);
		$model = $this->getModel($modelName);
		$modelObjectName = $model->getPhpName();

		return $database->getNamespace() . '\\' . $modelObjectName;
	}
	
	/**
	 * Returns the operation (verb) of the action (if existent)
	 * 
	 * @param ActionSchema $action
	 * @return string|null
	 */
	public function getOperationByAction(ActionSchema $action) {
		$actionName = $action->getName();
		$operation = null;
		if (($pos = strpos($actionName, '-')) !== false) {
			$operation = substr($actionName, $pos + 1);
		}
		return $operation;
	}
	
	/**
	 * Returns wether the given action refers to a model.
	 * 
	 * Examples:
	 * 
	 * Action: user-create => model: user
	 * Action: recover-password => no model
	 * 
	 * @param ActionSchema $action
	 * @return boolean
	 */
	public function isModelAction(ActionSchema $action) {
		$modelName = $this->getModelNameByAction($action);
		return $this->hasModel($modelName);
	}
	
	/**
	 * Returns whether this is a crud operation action
	 * (create, read, update, delete, list)
	 * 
	 * @param ActionSchema $action
	 * @return boolean
	 */
	public function isCrudAction(ActionSchema $action) {
		$operation = $this->getOperationByAction($action);
		
		return in_array($operation, ['create', 'read', 'update', 'delete', 'list']);
	}
	
	/**
	 * Returns all model relationships.
	 * 
	 * @param Table $model
	 * @return Relationships
	 */
	public function getRelationships(Table $model) {
		if ($this->relationships === null) {
			$this->relationships = new Map();
		}
		
		if ($this->relationships->has($model->getName())) {
			return $this->relationships->get($model->getName());
		}
		
		$blacklist = new Set();
		$relationships = new Relationships($model);
		
		// generate blacklist
		// check if it's using concrete_inheritance behavior
		foreach ($model->getBehaviors() as $behavior) {
			if ($behavior->getName() == 'concrete_inheritance') {
				$blacklist->add($behavior->getParameter('extends'));
			}
		}
		
		// to-one relationships
		foreach ($model->getForeignKeys() as $fk) {
			// skip, if fk is blacklisted 
			if ($blacklist->contains($fk->getForeignTable()->getOriginCommonName())) {
				continue;
			}

			$relationships->add(new Relationship($model, $fk->getForeignTable(), $fk));

It seems like $fk->getForeignTable() can be null; however, __construct() does not accept null, maybe add an additional type check?

		}
	
		// to-many relationships
		foreach ($model->getCrossFks() as $cfk) {
			$relationship = new ManyRelationship($model, $cfk);
			
			// skip, if fk is blacklisted
			if ($blacklist->contains($relationship->getForeign()->getOriginCommonName())) {
				continue;
			}
			
			$relationships->add($relationship);
		}
		
		$this->relationships->set($model->getName(), $relationships);
	
		return $relationships;
	}
	
	/**
	 * Returns a relationship for a given foreign name on a given model
	 * 
	 * @param Table $model
	 * @param string $foreignName
	 * @return Relationship
	 */
	public function getRelationship(Table $model, $foreignName) {
		$relationships = $this->getRelationships($model);
		return $relationships->get($foreignName);
	}
}