CheckConstraints::__construct() - Code Metrics - Inspection of "Add ResultsSource and auxiliary services to Constr..." - wikimedia/mediawiki-extensions-WikibaseQualityConstraints - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5c18d0...3ae30d )

unknown

created 2018-06-05 14:11 UTC

CheckConstraints::__construct() A

↳ Parent: CheckConstraints

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	20
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	18
nc	1
nop	9

How to fix Many Parameters

<?php

namespace WikibaseQuality\ConstraintReport\Api;

use ApiBase;
use ApiMain;
use IBufferingStatsdDataFactory;
use MediaWiki\MediaWikiServices;
use RequestContext;
use ValueFormatters\FormatterOptions;
use Wikibase\DataModel\Entity\EntityId;
use Wikibase\DataModel\Entity\EntityIdParser;
use Wikibase\DataModel\Entity\EntityIdParsingException;
use Wikibase\DataModel\Services\Statement\StatementGuidValidator;
use Wikibase\Lib\SnakFormatter;
use Wikibase\Repo\Api\ApiErrorReporter;
use Wikibase\Repo\Api\ApiHelperFactory;
use Wikibase\Repo\Api\ResultBuilder;
use Wikibase\Repo\EntityIdLabelFormatterFactory;
use Wikibase\Repo\WikibaseRepo;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Message\MultilingualTextViolationMessageRenderer;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Result\CheckResult;
use WikibaseQuality\ConstraintReport\ConstraintReportFactory;

/**
 * API module that performs constraint check of entities, claims and constraint ID
 *
 * @author Olga Bode
 * @license GPL-2.0-or-later
 */
class CheckConstraints extends ApiBase {

	const PARAM_ID = 'id';
	const PARAM_CLAIM_ID = 'claimid';
	const PARAM_CONSTRAINT_ID = 'constraintid';
	const PARAM_STATUS = 'status';

	/**
	 * @var EntityIdParser
	 */
	private $entityIdParser;

	/**
	 * @var StatementGuidValidator
	 */
	private $statementGuidValidator;

	/**
	 * @var ResultBuilder
	 */
	private $resultBuilder;

	/**
	 * @var ApiErrorReporter
	 */
	private $errorReporter;

	/**
	 * @var ResultsSource
	 */
	private $resultsSource;

	/**
	 * @var CheckResultsRenderer
	 */
	private $checkResultsRenderer;

	/**
	 * @var IBufferingStatsdDataFactory
	 */
	private $dataFactory;

	/**
	 * Creates new instance from global state.
	 *
	 * @param ApiMain $main
	 * @param string $name
	 * @param string $prefix
	 *
	 * @return self
	 */
	public static function newFromGlobalState( ApiMain $main, $name, $prefix = '' ) {
		$repo = WikibaseRepo::getDefaultInstance();

		$language = $repo->getUserLanguage();
		$formatterOptions = new FormatterOptions();
		$formatterOptions->setOption( SnakFormatter::OPT_LANG, $language->getCode() );
		$valueFormatterFactory = $repo->getValueFormatterFactory();
		$valueFormatter = $valueFormatterFactory->getValueFormatter( SnakFormatter::FORMAT_HTML, $formatterOptions );

		$languageFallbackLabelDescriptionLookupFactory = $repo->getLanguageFallbackLabelDescriptionLookupFactory();
		$labelDescriptionLookup = $languageFallbackLabelDescriptionLookupFactory->newLabelDescriptionLookup( $language );
		$entityIdHtmlLinkFormatterFactory = $repo->getEntityIdHtmlLinkFormatterFactory();
		$entityIdHtmlLinkFormatter = $entityIdHtmlLinkFormatterFactory->getEntityIdFormatter( $labelDescriptionLookup );
		$entityIdLabelFormatterFactory = new EntityIdLabelFormatterFactory();
		$entityIdLabelFormatter = $entityIdLabelFormatterFactory->getEntityIdFormatter( $labelDescriptionLookup );
		$config = MediaWikiServices::getInstance()->getMainConfig();
		$dataFactory = MediaWikiServices::getInstance()->getStatsdDataFactory();
		$constraintReportFactory = ConstraintReportFactory::getDefaultInstance();

		$checkResultsRenderer = new CheckResultsRenderer(
			$repo->getEntityTitleLookup(),
			$entityIdLabelFormatter,
			new MultilingualTextViolationMessageRenderer(
				$entityIdHtmlLinkFormatter,
				$valueFormatter,
				$main,
				$config
			),
			$config
		);
		$resultsSource = $constraintReportFactory->getResultsSource();

		return new CheckConstraints(
			$main,
			$name,
			$prefix,
			$repo->getEntityIdParser(),
			$repo->getStatementGuidValidator(),
			$repo->getApiHelperFactory( RequestContext::getMain() ),
			$resultsSource,
			$checkResultsRenderer,
			$dataFactory
		);
	}

	/**
	 * @param ApiMain $main
	 * @param string $name
	 * @param string $prefix
	 * @param EntityIdParser $entityIdParser
	 * @param StatementGuidValidator $statementGuidValidator
	 * @param ApiHelperFactory $apiHelperFactory
	 * @param ResultsSource $resultsSource
	 * @param CheckResultsRenderer $checkResultsRenderer
	 * @param IBufferingStatsdDataFactory $dataFactory
	 */
	public function __construct(
		ApiMain $main,
		$name,
		$prefix,
		EntityIdParser $entityIdParser,
		StatementGuidValidator $statementGuidValidator,
		ApiHelperFactory $apiHelperFactory,
		ResultsSource $resultsSource,
		CheckResultsRenderer $checkResultsRenderer,
		IBufferingStatsdDataFactory $dataFactory
	) {
		parent::__construct( $main, $name, $prefix );
		$this->entityIdParser = $entityIdParser;
		$this->statementGuidValidator = $statementGuidValidator;
		$this->resultBuilder = $apiHelperFactory->getResultBuilder( $this );
		$this->errorReporter = $apiHelperFactory->getErrorReporter( $this );
		$this->resultsSource = $resultsSource;
		$this->checkResultsRenderer = $checkResultsRenderer;
		$this->dataFactory = $dataFactory;
	}

	/**
	 * Evaluates the parameters, runs the requested constraint check, and sets up the result
	 */
	public function execute() {
		$this->dataFactory->increment(
			'wikibase.quality.constraints.api.checkConstraints.execute'
		);

		$params = $this->extractRequestParams();

		$this->validateParameters( $params );
		$entityIds = $this->parseEntityIds( $params );
		$claimIds = $this->parseClaimIds( $params );
		$constraintIDs = $params[self::PARAM_CONSTRAINT_ID];
		$statuses = $params[self::PARAM_STATUS];

		$this->getResult()->addValue(
			null,
			$this->getModuleName(),
			$this->checkResultsRenderer->render(
				$this->resultsSource->getResults(
					$entityIds,
					$claimIds,
					$constraintIDs,
					$statuses
				)
			)->getArray()
		);
		$this->resultBuilder->markSuccess( 1 );
	}

	/**
	 * @param array $params
	 *
	 * @return EntityId[]
	 */
	private function parseEntityIds( array $params ) {
		$ids = $params[self::PARAM_ID];

		if ( $ids === null ) {
			return [];
		} elseif ( $ids === [] ) {
			$this->errorReporter->dieError(
				'If ' . self::PARAM_ID . ' is specified, it must be nonempty.', 'no-data' );
		}

		return array_map( function ( $id ) {
			try {
				return $this->entityIdParser->parse( $id );
			} catch ( EntityIdParsingException $e ) {
				$this->errorReporter->dieError(
					"Invalid id: $id", 'invalid-entity-id', 0, [ self::PARAM_ID => $id ] );
			}
		}, $ids );
	}

	/**
	 * @param array $params
	 *
	 * @return string[]
	 */
	private function parseClaimIds( array $params ) {
		$ids = $params[self::PARAM_CLAIM_ID];

		if ( $ids === null ) {
			return [];
		} elseif ( $ids === [] ) {
			$this->errorReporter->dieError(
				'If ' . self::PARAM_CLAIM_ID . ' is specified, it must be nonempty.', 'no-data' );
		}

		foreach ( $ids as $id ) {
			if ( !$this->statementGuidValidator->validate( $id ) ) {
				$this->errorReporter->dieError(
					"Invalid claim id: $id", 'invalid-guid', 0, [ self::PARAM_CLAIM_ID => $id ] );
			}
		}

		return $ids;
	}

	private function validateParameters( array $params ) {
		if ( $params[self::PARAM_CONSTRAINT_ID] !== null
			 && empty( $params[self::PARAM_CONSTRAINT_ID] )
		) {
			$paramConstraintId = self::PARAM_CONSTRAINT_ID;
			$this->errorReporter->dieError(
				"If $paramConstraintId is specified, it must be nonempty.", 'no-data' );
		}
		if ( $params[self::PARAM_ID] === null && $params[self::PARAM_CLAIM_ID] === null ) {
			$paramId = self::PARAM_ID;
			$paramClaimId = self::PARAM_CLAIM_ID;
			$this->errorReporter->dieError(
				"At least one of $paramId, $paramClaimId must be specified.", 'no-data' );
		}
		// contents of PARAM_ID and PARAM_CLAIM_ID are validated by parse{Entity,Claim}Ids()
	}

	/**
	 * @return array[]
	 * @codeCoverageIgnore
	 */
	public function getAllowedParams() {
		return [
			self::PARAM_ID => [
				ApiBase::PARAM_TYPE => 'string',
				ApiBase::PARAM_ISMULTI => true,
			],
			self::PARAM_CLAIM_ID => [
				ApiBase::PARAM_TYPE => 'string',
				ApiBase::PARAM_ISMULTI => true,
			],
			self::PARAM_CONSTRAINT_ID => [
				ApiBase::PARAM_TYPE => 'string',
				ApiBase::PARAM_ISMULTI => true,
			],
			self::PARAM_STATUS => [
				ApiBase::PARAM_TYPE => [
					CheckResult::STATUS_COMPLIANCE,
					CheckResult::STATUS_VIOLATION,
					CheckResult::STATUS_WARNING,
					CheckResult::STATUS_EXCEPTION,
					CheckResult::STATUS_NOT_IN_SCOPE,
					CheckResult::STATUS_DEPRECATED,
					CheckResult::STATUS_BAD_PARAMETERS,
					CheckResult::STATUS_TODO,
				],
				ApiBase::PARAM_ISMULTI => true,
				ApiBase::PARAM_ALL => true,
				ApiBase::PARAM_DFLT => implode( '|', [
					CheckResult::STATUS_VIOLATION,
					CheckResult::STATUS_WARNING,
					CheckResult::STATUS_BAD_PARAMETERS,
				] ),
				ApiBase::PARAM_HELP_MSG_PER_VALUE => [],
			],
		];
	}

	/**
	 * Returns usage examples for this module
	 *
	 * @return string[]
	 * @codeCoverageIgnore
	 */
	public function getExamplesMessages() {
		return [
			'action=wbcheckconstraints&id=Q5|Q42'
				=> 'apihelp-wbcheckconstraints-example-1',
			'action=wbcheckconstraints&claimid=q42%248419C20C-8EF8-4EC0-80D6-AF1CA55E7557'
				=> 'apihelp-wbcheckconstraints-example-2',
			'action=wbcheckconstraints&format=json&id=Q2&constraintid=P1082%24DA39C2DA-47DA-48FB-8A9A-DA80200FB2DB'
				=> 'apihelp-wbcheckconstraints-example-3',
		];
	}

}


1			<?php
2
3			namespace WikibaseQuality\ConstraintReport\Api;
4
5			use ApiBase;
6			use ApiMain;
7			use IBufferingStatsdDataFactory;
8			use MediaWiki\MediaWikiServices;
9			use RequestContext;
10			use ValueFormatters\FormatterOptions;
11			use Wikibase\DataModel\Entity\EntityId;
12			use Wikibase\DataModel\Entity\EntityIdParser;
13			use Wikibase\DataModel\Entity\EntityIdParsingException;
14			use Wikibase\DataModel\Services\Statement\StatementGuidValidator;
15			use Wikibase\Lib\SnakFormatter;
16			use Wikibase\Repo\Api\ApiErrorReporter;
17			use Wikibase\Repo\Api\ApiHelperFactory;
18			use Wikibase\Repo\Api\ResultBuilder;
19			use Wikibase\Repo\EntityIdLabelFormatterFactory;
20			use Wikibase\Repo\WikibaseRepo;
21			use WikibaseQuality\ConstraintReport\ConstraintCheck\Message\MultilingualTextViolationMessageRenderer;
22			use WikibaseQuality\ConstraintReport\ConstraintCheck\Result\CheckResult;
23			use WikibaseQuality\ConstraintReport\ConstraintReportFactory;
24
25			/**
26			* API module that performs constraint check of entities, claims and constraint ID
27			*
28			* @author Olga Bode
29			* @license GPL-2.0-or-later
30			*/
31			class CheckConstraints extends ApiBase {
32
33			const PARAM_ID = 'id';
34			const PARAM_CLAIM_ID = 'claimid';
35			const PARAM_CONSTRAINT_ID = 'constraintid';
36			const PARAM_STATUS = 'status';
37
38			/**
39			* @var EntityIdParser
40			*/
41			private $entityIdParser;
42
43			/**
44			* @var StatementGuidValidator
45			*/
46			private $statementGuidValidator;
47
48			/**
49			* @var ResultBuilder
50			*/
51			private $resultBuilder;
52
53			/**
54			* @var ApiErrorReporter
55			*/
56			private $errorReporter;
57
58			/**
59			* @var ResultsSource
60			*/
61			private $resultsSource;
62
63			/**
64			* @var CheckResultsRenderer
65			*/
66			private $checkResultsRenderer;
67
68			/**
69			* @var IBufferingStatsdDataFactory
70			*/
71			private $dataFactory;
72
73			/**
74			* Creates new instance from global state.
75			*
76			* @param ApiMain $main
77			* @param string $name
78			* @param string $prefix
79			*
80			* @return self
81			*/
82			public static function newFromGlobalState( ApiMain $main, $name, $prefix = '' ) {
83			$repo = WikibaseRepo::getDefaultInstance();
84
85			$language = $repo->getUserLanguage();
86			$formatterOptions = new FormatterOptions();
87			$formatterOptions->setOption( SnakFormatter::OPT_LANG, $language->getCode() );
88			$valueFormatterFactory = $repo->getValueFormatterFactory();
89			$valueFormatter = $valueFormatterFactory->getValueFormatter( SnakFormatter::FORMAT_HTML, $formatterOptions );
90
91			$languageFallbackLabelDescriptionLookupFactory = $repo->getLanguageFallbackLabelDescriptionLookupFactory();
92			$labelDescriptionLookup = $languageFallbackLabelDescriptionLookupFactory->newLabelDescriptionLookup( $language );
93			$entityIdHtmlLinkFormatterFactory = $repo->getEntityIdHtmlLinkFormatterFactory();
94			$entityIdHtmlLinkFormatter = $entityIdHtmlLinkFormatterFactory->getEntityIdFormatter( $labelDescriptionLookup );
95			$entityIdLabelFormatterFactory = new EntityIdLabelFormatterFactory();
96			$entityIdLabelFormatter = $entityIdLabelFormatterFactory->getEntityIdFormatter( $labelDescriptionLookup );
97			$config = MediaWikiServices::getInstance()->getMainConfig();
98			$dataFactory = MediaWikiServices::getInstance()->getStatsdDataFactory();
99			$constraintReportFactory = ConstraintReportFactory::getDefaultInstance();
100
101			$checkResultsRenderer = new CheckResultsRenderer(
102			$repo->getEntityTitleLookup(),
103			$entityIdLabelFormatter,
104			new MultilingualTextViolationMessageRenderer(
105			$entityIdHtmlLinkFormatter,
106			$valueFormatter,
107			$main,
108			$config
109			),
110			$config
111			);
112			$resultsSource = $constraintReportFactory->getResultsSource();
113
114			return new CheckConstraints(
115			$main,
116			$name,
117			$prefix,
118			$repo->getEntityIdParser(),
119			$repo->getStatementGuidValidator(),
120			$repo->getApiHelperFactory( RequestContext::getMain() ),
121			$resultsSource,
122			$checkResultsRenderer,
123			$dataFactory
124			);
125			}
126
127			/**
128			* @param ApiMain $main
129			* @param string $name
130			* @param string $prefix
131			* @param EntityIdParser $entityIdParser
132			* @param StatementGuidValidator $statementGuidValidator
133			* @param ApiHelperFactory $apiHelperFactory
134			* @param ResultsSource $resultsSource
135			* @param CheckResultsRenderer $checkResultsRenderer
136			* @param IBufferingStatsdDataFactory $dataFactory
137			*/
138			public function __construct(
139			ApiMain $main,
140			$name,
141			$prefix,
142			EntityIdParser $entityIdParser,
143			StatementGuidValidator $statementGuidValidator,
144			ApiHelperFactory $apiHelperFactory,
145			ResultsSource $resultsSource,
146			CheckResultsRenderer $checkResultsRenderer,
147			IBufferingStatsdDataFactory $dataFactory
148			) {
149			parent::__construct( $main, $name, $prefix );
150			$this->entityIdParser = $entityIdParser;
151			$this->statementGuidValidator = $statementGuidValidator;
152			$this->resultBuilder = $apiHelperFactory->getResultBuilder( $this );
153			$this->errorReporter = $apiHelperFactory->getErrorReporter( $this );
154			$this->resultsSource = $resultsSource;
155			$this->checkResultsRenderer = $checkResultsRenderer;
156			$this->dataFactory = $dataFactory;
157			}
158
159			/**
160			* Evaluates the parameters, runs the requested constraint check, and sets up the result
161			*/
162			public function execute() {
163			$this->dataFactory->increment(
164			'wikibase.quality.constraints.api.checkConstraints.execute'
165			);
166
167			$params = $this->extractRequestParams();
168
169			$this->validateParameters( $params );
170			$entityIds = $this->parseEntityIds( $params );
171			$claimIds = $this->parseClaimIds( $params );
172			$constraintIDs = $params[self::PARAM_CONSTRAINT_ID];
173			$statuses = $params[self::PARAM_STATUS];
174
175			$this->getResult()->addValue(
176			null,
177			$this->getModuleName(),
178			$this->checkResultsRenderer->render(
179			$this->resultsSource->getResults(
180			$entityIds,
181			$claimIds,
182			$constraintIDs,
183			$statuses
184			)
185			)->getArray()
186			);
187			$this->resultBuilder->markSuccess( 1 );
188			}
189
190			/**
191			* @param array $params
192			*
193			* @return EntityId[]
194			*/
195			private function parseEntityIds( array $params ) {
196			$ids = $params[self::PARAM_ID];
197
198			if ( $ids === null ) {
199			return [];
200			} elseif ( $ids === [] ) {
201			$this->errorReporter->dieError(
202			'If ' . self::PARAM_ID . ' is specified, it must be nonempty.', 'no-data' );
203			}
204
205			return array_map( function ( $id ) {
206			try {
207			return $this->entityIdParser->parse( $id );
208			} catch ( EntityIdParsingException $e ) {
209			$this->errorReporter->dieError(
210			"Invalid id: $id", 'invalid-entity-id', 0, [ self::PARAM_ID => $id ] );
211			}
212			}, $ids );
213			}
214
215			/**
216			* @param array $params
217			*
218			* @return string[]
219			*/
220			private function parseClaimIds( array $params ) {
221			$ids = $params[self::PARAM_CLAIM_ID];
222
223			if ( $ids === null ) {
224			return [];
225			} elseif ( $ids === [] ) {
226			$this->errorReporter->dieError(
227			'If ' . self::PARAM_CLAIM_ID . ' is specified, it must be nonempty.', 'no-data' );
228			}
229
230			foreach ( $ids as $id ) {
231			if ( !$this->statementGuidValidator->validate( $id ) ) {
232			$this->errorReporter->dieError(
233			"Invalid claim id: $id", 'invalid-guid', 0, [ self::PARAM_CLAIM_ID => $id ] );
234			}
235			}
236
237			return $ids;
238			}
239
240			private function validateParameters( array $params ) {
241			if ( $params[self::PARAM_CONSTRAINT_ID] !== null
242			&& empty( $params[self::PARAM_CONSTRAINT_ID] )
243			) {
244			$paramConstraintId = self::PARAM_CONSTRAINT_ID;
245			$this->errorReporter->dieError(
246			"If $paramConstraintId is specified, it must be nonempty.", 'no-data' );
247			}
248			if ( $params[self::PARAM_ID] === null && $params[self::PARAM_CLAIM_ID] === null ) {
249			$paramId = self::PARAM_ID;
250			$paramClaimId = self::PARAM_CLAIM_ID;
251			$this->errorReporter->dieError(
252			"At least one of $paramId, $paramClaimId must be specified.", 'no-data' );
253			}
254			// contents of PARAM_ID and PARAM_CLAIM_ID are validated by parse{Entity,Claim}Ids()
255			}
256
257			/**
258			* @return array[]
259			* @codeCoverageIgnore
260			*/
261			public function getAllowedParams() {
262			return [
263			self::PARAM_ID => [
264			ApiBase::PARAM_TYPE => 'string',
265			ApiBase::PARAM_ISMULTI => true,
266			],
267			self::PARAM_CLAIM_ID => [
268			ApiBase::PARAM_TYPE => 'string',
269			ApiBase::PARAM_ISMULTI => true,
270			],
271			self::PARAM_CONSTRAINT_ID => [
272			ApiBase::PARAM_TYPE => 'string',
273			ApiBase::PARAM_ISMULTI => true,
274			],
275			self::PARAM_STATUS => [
276			ApiBase::PARAM_TYPE => [
277			CheckResult::STATUS_COMPLIANCE,
278			CheckResult::STATUS_VIOLATION,
279			CheckResult::STATUS_WARNING,
280			CheckResult::STATUS_EXCEPTION,
281			CheckResult::STATUS_NOT_IN_SCOPE,
282			CheckResult::STATUS_DEPRECATED,
283			CheckResult::STATUS_BAD_PARAMETERS,
284			CheckResult::STATUS_TODO,
285			],
286			ApiBase::PARAM_ISMULTI => true,
287			ApiBase::PARAM_ALL => true,
288			ApiBase::PARAM_DFLT => implode( '\|', [
289			CheckResult::STATUS_VIOLATION,
290			CheckResult::STATUS_WARNING,
291			CheckResult::STATUS_BAD_PARAMETERS,
292			] ),
293			ApiBase::PARAM_HELP_MSG_PER_VALUE => [],
294			],
295			];
296			}
297
298			/**
299			* Returns usage examples for this module
300			*
301			* @return string[]
302			* @codeCoverageIgnore
303			*/
304			public function getExamplesMessages() {
305			return [
306			'action=wbcheckconstraints&id=Q5\|Q42'
307			=> 'apihelp-wbcheckconstraints-example-1',
308			'action=wbcheckconstraints&claimid=q42%248419C20C-8EF8-4EC0-80D6-AF1CA55E7557'
309			=> 'apihelp-wbcheckconstraints-example-2',
310			'action=wbcheckconstraints&format=json&id=Q2&constraintid=P1082%24DA39C2DA-47DA-48FB-8A9A-DA80200FB2DB'
311			=> 'apihelp-wbcheckconstraints-example-3',
312			];
313			}
314
315			}
316

wikimedia / mediawiki-extensions-WikibaseQualityConstraints

Push — master ( 5c18d0...3ae30d )

CheckConstraints::__construct() A

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like