keeko\tools\services\PackageService

Complexity

Total Complexity

26

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

84.31%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getPackage()	0	12	3
A	getNamespace()	0	16	4
A	getKeeko()	0	8	2
A	getModule()	0	8	2
A	getApp()	0	8	2
A	getAction()	0	8	3
B	getActionType()	0	12	5
A	savePackage()	0	9	2
A	getOperationByAction()	0	8	2
A	isCrudAction()	0	5	1

<?php
namespace keeko\tools\services;

use keeko\framework\schema\PackageSchema;
use phootwork\file\exception\FileException;
use phootwork\file\File;
use keeko\tools\utils\NamespaceResolver;
use keeko\framework\schema\ActionSchema;
use keeko\framework\schema\ModuleSchema;

class PackageService extends AbstractService {

	/** @var PackageSchema */
	private $package = null;
	private $keeko = null;
	private $module = null;
	private $app = null;
	private $namespace = null;
	
	/**
	 *
	 * @throws FileException
	 * @return PackageSchema
	 */
	public function getPackage() {
		if ($this->package === null) {
			$file = new File($this->service->getProject()->getComposerFileName());
			if ($file->exists()) {
				$this->package = PackageSchema::fromFile($file->getPathname());
			} else {
				$this->package = new PackageSchema();
			}
		}

		return $this->package;
	}
	
	/**
	 * Returns the root namespace for this package
	 *
	 * @return string the namespace
	 */
	public function getNamespace() {
		if ($this->namespace === null) {
			$input = $this->io->getInput();
			$ns = $input->hasOption('namespace')
			? $input->getOption('namespace')
			: null;
			if ($ns === null) {
				$package = $this->service->getPackageService()->getPackage();
				$ns = NamespaceResolver::getNamespace('src', $package);
			}
	
			$this->namespace = trim($ns, '\\');
		}
	
		return $this->namespace;
	}
	
	/**
	 * Returns the keeko node from the composer.json extra
	 *
	 * @return KeekoSchema
	 */
	public function getKeeko() {
		if ($this->keeko === null) {
			$package = $this->getPackage();
			$this->keeko = $package->getKeeko();
		}
	
		return $this->keeko;
	}
	
	/**
	 * Returns the keeko module schema
	 *
	 * @return ModuleSchema
	 */
	public function getModule() {
		if ($this->module === null) {
			$keeko = $this->getKeeko();
			$this->module = $keeko->getModule();
		}
	
		return $this->module;
	}
	
	/**
	 * Returns the keeko app schema
	 *
	 * @return AppSchema
	 */
	public function getApp() {
		if ($this->app === null) {
			$keeko = $this->getKeeko();
			$this->app = $keeko->getApp();
		}
	
		return $this->app;
	}
	
	/**
	 * Returns an action
	 *
	 * @param string $name
	 * @return ActionSchema
	 */
	public function getAction($name) {
		$module = $this->getModule();
		if ($module !== null && $module->hasAction($name)) {
			return $module->getAction($name);
		}

		return null;
	}

	public function getActionType($actionName, $modelName) {
		$input = $this->io->getInput();
		$type = $input->hasOption('type') ? $input->getOption('type') : null;
		if ($type === null) {
			if (($pos = strrpos($actionName, '-')) !== false) {
				$type = substr($actionName, $pos + 1);
			} else if ($modelName == $actionName) {
				$type = 'read';
			}
		}
		return $type;
	}
	
	public function savePackage(PackageSchema $package = null) {
		if ($package === null) {
			$package = $this->getPackage();
		}
		
		$filename = $this->service->getProject()->getComposerFileName();
		$this->service->getJsonService()->write($filename, $package->toArray());
		$this->io->writeln(sprintf('Package <info>%s</info> written at <info>%s</info>', $package->getFullName(), $filename));
	}
	
	// --- from model service ----
	
	/**
	 * 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 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']);
	}
}