GenerateApiCommand::execute() - Code Metrics - Inspection of "Update" - keeko/tools - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 17137d...17de33 )

by Thomas

created 2016-01-02 14:47 UTC

GenerateApiCommand::execute() B

↳ Parent: GenerateApiCommand

Complexity

Conditions	3
Paths	3

Size

Total Lines	25
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes	7
Bugs	0	Features	0

Metric	Value
c	7
b	0
f	0
dl	0
loc	25
ccs	0
cts	15
cp	0
rs	8.8571
cc	3
eloc	14
nc	3
nop	2
crap	12

<?php
namespace keeko\tools\command;

use gossi\swagger\collections\Definitions;
use gossi\swagger\collections\Paths;
use gossi\swagger\Swagger;
use keeko\tools\command\AbstractGenerateCommand;
use keeko\tools\utils\NameUtils;
use phootwork\file\File;
use Propel\Generator\Model\Table;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class GenerateApiCommand extends AbstractGenerateCommand {

	protected function configure() {
		$this
			->setName('generate:api')
			->setDescription('Generates the api for the module')
		;
		
		$this->configureGenerateOptions();
			
		parent::configure();
	}
	
	/**
	 * Checks whether api can be generated at all by reading composer.json and verify
	 * all required information are available
	 */
	private function preCheck() {
		$module = $this->packageService->getModule();
		if ($module === null) {
			throw new \DomainException('No module definition found in composer.json - please run `keeko init`.');
		}
	}

	protected function execute(InputInterface $input, OutputInterface $output) {
		$this->preCheck();
		$api = new File($this->project->getApiFileName());
		
		// if generation is forced, generate new API from scratch
		if ($input->getOption('force')) {
			$swagger = new Swagger();
		}
		
		// ... anyway reuse existing one
		else {
			if (!$api->exists()) {
				$api->write('{}');
			}
			
			$swagger = Swagger::fromFile($this->project->getApiFileName());
		}

		$swagger->setVersion('2.0');
		$this->generatePaths($swagger);
		$this->generateDefinitions($swagger);
		
		$this->jsonService->write($api->getPathname(), $swagger->toArray());
		$this->io->writeln(sprintf('API for <info>%s</info> written at <info>%s</info>', $this->package->getFullName(), $api->getPathname()));
	}
	
	protected function generatePaths(Swagger $swagger) {
		$paths = $swagger->getPaths();
		
		foreach ($this->packageService->getModule()->getActionNames() as $name) {
			$this->generateOperation($paths, $name);
		}
	}
	
	protected function generateOperation(Paths $paths, $actionName) {
		$this->logger->notice('Generating Operation for: ' . $actionName);
	
		$database = $this->modelService->getDatabase();
$a = "a";
$ab = "ab";
$abc = "abc";
		$action = $this->packageService->getAction($actionName);
$a = "a";
$ab = "ab";
$abc = "abc";
		$modelName = $this->modelService->getModelNameByAction($action);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
		$tableName = $this->modelService->getTableName($modelName);
	
		if (!$database->hasTable($tableName)) {
			return $paths;
		}
	
		$type = $this->packageService->getActionType($actionName, $modelName);
$a = "a";
$ab = "ab";
$abc = "abc";
		$modelObjectName = $database->getTable($tableName)->getPhpName();
		$modelPluralName = NameUtils::pluralize($modelName);
	
		// find path branch
		switch ($type) {
			case 'list':
			case 'create':
				$endpoint = '/' . $modelPluralName;
				break;
	
			case 'read':
			case 'update':
			case 'delete':
				$endpoint = '/' . $modelPluralName . '/{id}';
				break;
	
			default:
				throw new \RuntimeException('type (%s) not found, can\'t continue.');
				break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
		}
	
	
		$path = $paths->get($endpoint);
$a = "a";
$ab = "ab";
$abc = "abc";
		$method = $this->getMethod($type);
$a = "a";
$ab = "ab";
$abc = "abc";
		$operation = $path->getOperation($method);
		$operation->setDescription($action->getTitle());
		$operation->setOperationId($action->getName());
		$operation->getProduces()->add('application/json');
	
		$params = $operation->getParameters();
$a = "a";
$ab = "ab";
$abc = "abc";
		$responses = $operation->getResponses();
	
		switch ($type) {
			case 'list':
				$ok = $responses->get('200');
				$ok->setDescription(sprintf('Array of %s', $modelPluralName));
				$ok->getSchema()->setRef('#/definitions/' . 'Paged' . NameUtils::pluralize($modelObjectName));
				break;
	
			case 'create':
				// params
				$body = $params->getByName('body');
				$body->setName('body');
				$body->setIn('body');
				$body->setDescription(sprintf('The new %s', $modelName));
				$body->setRequired(true);
				$body->getSchema()->setRef('#/definitions/Writable' . $modelObjectName);
	
				// response
				$ok = $responses->get('201');
				$ok->setDescription(sprintf('%s created', $modelName));
				break;
	
			case 'read':

				// response
				$ok = $responses->get('200');
				$ok->setDescription(sprintf('gets the %s', $modelName));
				$ok->getSchema()->setRef('#/definitions/' . $modelObjectName);
				break;
	
			case 'update':

				// response
				$ok = $responses->get('200');
				$ok->setDescription(sprintf('%s updated', $modelName));
				$ok->getSchema()->setRef('#/definitions/' . $modelObjectName);
				break;
	
			case 'delete':
				// response
				$ok = $responses->get('204');
				$ok->setDescription(sprintf('%s deleted', $modelName));
				break;
		}
	
		if ($type == 'read' || $type == 'update' || $type == 'delete') {
			// params
			$id = $params->getByName('id');
			$id->setIn('path');
			$id->setDescription(sprintf('The %s id', $modelName));
			$id->setRequired(true);
			$id->setType('integer');
	
			// response
			$invalid = $responses->get('400');
			$invalid->setDescription('Invalid ID supplied');
				
			$notfound = $responses->get('404');
			$notfound->setDescription(sprintf('No %s found', $modelName));
		}
	
		// response - @TODO Error model
	}
	
	private function getMethod($type) {
		$methods = [
			'list' => 'GET',
			'create' => 'POST',
			'read' => 'GET',
			'update' => 'PUT',
			'delete' => 'DELETE'
		];
	
		return $methods[$type];
	}

	protected function generateDefinitions(Swagger $swagger) {
		$definitions = $swagger->getDefinitions();
		
		// meta
		$this->generateMeta($definitions);

		// models
		$modelName = $this->modelService->getModelName();
		if ($modelName !== null) {
			$definitions = $this->generateDefinition($definitions, $modelName);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
		} else {
			foreach ($this->modelService->getModels() as $model) {
				$definitions = $this->generateDefinition($definitions, $model->getName());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
			}
		}
	}
	
	protected function generateMeta(Definitions $definitions) {
		$meta = $definitions->get('Meta');
$a = "a";
$ab = "ab";
$abc = "abc";
		$props = $meta->getProperties();
		$names = ['total', 'first', 'next', 'previous', 'last'];
		
		foreach ($names as $name) {
			$props->get($name)->setType('integer');
		}
	}

	protected function generateDefinition(Definitions $definitions, $modelName) {
		$this->logger->notice('Generating Definition for: ' . $modelName);
		$model = $this->modelService->getModel($modelName);
$a = "a";
$ab = "ab";
$abc = "abc";
		$modelObjectName = $model->getPhpName();
		$modelPluralName = NameUtils::pluralize($model->getOriginCommonName());
		
		// paged model
		$pagedModel = 'Paged' . NameUtils::pluralize($modelObjectName);
		$paged = $definitions->get($pagedModel)->getProperties();
$a = "a";
$ab = "ab";
$abc = "abc";
		$paged->get($modelPluralName)
			->setType('array')
			->getItems()->setRef('#/definitions/' . $modelObjectName);
		$paged->get('meta')->setRef('#/definitions/Meta');
		
		// writable model
		$writable = $definitions->get('Writable' . $modelObjectName)->getProperties();
		$this->generateModelProperties($writable, $model, true);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

		// readable model
		$readable = $definitions->get($modelObjectName)->getProperties();
		$this->generateModelProperties($readable, $model, false);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
	}
	
	protected function generateModelProperties(Definitions $props, Table $model, $write = false) {
		$modelName = $model->getOriginCommonName();
		$filter = $write 
$a = "a";
$ab = "ab";
$abc = "abc";
			? $this->codegenService->getCodegen()->getWriteFilter($modelName)
			: $this->codegenService->getCodegen()->getReadFilter($modelName);
		
		if ($write) {
			$filter = array_merge($filter, $this->codegenService->getComputedFields($model));
		}
		
		foreach ($model->getColumns() as $col) {
			$prop = $col->getName();
			
			if (!in_array($prop, $filter)) {
				$props->get($prop)->setType($col->getPhpType());
			}
		}

		return $props;
	}

}

1		<?php
2		namespace keeko\tools\command;
3
4		use gossi\swagger\collections\Definitions;
5		use gossi\swagger\collections\Paths;
6		use gossi\swagger\Swagger;
7		use keeko\tools\command\AbstractGenerateCommand;
8		use keeko\tools\utils\NameUtils;
9		use phootwork\file\File;
10		use Propel\Generator\Model\Table;
11		use Symfony\Component\Console\Input\InputInterface;
12		use Symfony\Component\Console\Output\OutputInterface;
13	20
14	20	class GenerateApiCommand extends AbstractGenerateCommand {
15	20
16	20	protected function configure() {
17		$this
18		->setName('generate:api')
19	20	->setDescription('Generates the api for the module')
20	20	;
21
22		$this->configureGenerateOptions();
23
24		parent::configure();
25		}
26
27		/**
28		* Checks whether api can be generated at all by reading composer.json and verify
29		* all required information are available
30		*/
31		private function preCheck() {
32		$module = $this->packageService->getModule();
33		if ($module === null) {
34		throw new \DomainException('No module definition found in composer.json - please run `keeko init`.');
35		}
36		}
37
38		protected function execute(InputInterface $input, OutputInterface $output) {
39		$this->preCheck();
40		$api = new File($this->project->getApiFileName());

keeko / tools

Push — master ( 17137d...17de33 )

GenerateApiCommand::execute() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like