Assert that value is instance of given class-name.
/**
* @param $partId
* @return \Modules\Parts\ReadModel\PartsThatWereManufactured
*/
public function getReadModel($partId)
{
$partId = (string) $partId;
$readModel = $this->repository->find($partId);
Assertion::isInstanceOf($readModel, PartsThatWereManufactured::class);
return $readModel;
}
/**
* @param ServiceLocatorInterface $serviceLocator
*
* @return CommonReport
* @throws \Zend\ServiceManager\Exception\ServiceNotFoundException
* @throws \Assert\AssertionFailedException
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$appServiceLocator = $serviceLocator instanceof AbstractPluginManager ? $serviceLocator->getServiceLocator() : $serviceLocator;
/** @var ModuleOptionsPluginManagerInterface $moduleOptionsManager */
$moduleOptionsManager = $appServiceLocator->get(ModuleOptionsPluginManagerInterface::class);
Assertion::isInstanceOf($moduleOptionsManager, ModuleOptionsPluginManagerInterface::class, sprintf('Module options manager not implement %s', ModuleOptionsPluginManagerInterface::class));
/** @var ModuleOptions $moduleOptions */
$moduleOptions = $moduleOptionsManager->get(ModuleOptions::class);
Assertion::isInstanceOf($moduleOptions, ModuleOptions::class, sprintf('Module options not implement %s', ModuleOptions::class));
/** @var GoogleSheetsStorageBuilder $googleSheetsStorageBuilder */
$googleSheetsStorageBuilder = $appServiceLocator->get(GoogleSheetsStorageBuilder::class);
Assertion::isInstanceOf($googleSheetsStorageBuilder, GoogleSheetsStorageBuilder::class, sprintf('GoogleSheetsStorageBuilder not implement %s', GoogleSheetsStorageBuilder::class));
/** @var GitLabDataStorageBuilder $gitLabDataStorageBuilder */
$gitLabDataStorageBuilder = $appServiceLocator->get(GitLabDataStorageBuilder::class);
Assertion::isInstanceOf($gitLabDataStorageBuilder, GitLabDataStorageBuilder::class, sprintf('GitLabDataStorageBuilder not implement %s', GitLabDataStorageBuilder::class));
$report = new CommonReport($googleSheetsStorageBuilder, $gitLabDataStorageBuilder);
if ($report instanceof LoggerAwareInterface) {
$loggerName = $moduleOptions->getLogger();
if (null !== $loggerName) {
/** @var LoggerInterface $logger */
$logger = $appServiceLocator->get($loggerName);
Assertion::isInstanceOf($logger, LoggerInterface::class, sprintf('Log not implement %s', LoggerInterface::class));
$report->setLogger($logger);
}
}
return $report;
}
/**
* {@inheritdoc}
*/
public function authenticate($subject, Caller $caller)
{
Assertion::isArray($subject);
Assertion::choicesNotEmpty($subject, ['password']);
Assertion::isInstanceOf($caller, 'Guardian\\User\\Caller', sprintf('The caller was expected to be an instance of "%s"', 'Indigo\\Guardian\\Caller\\User'));
return $this->hasher->verify($subject['password'], $caller->getPassword());
}
/**
* @Given /^I have some generated config at "([^"]*)"$/
*/
public function iHaveSomeGeneratedConfigAt($arg1)
{
$this->configFilePath = getcwd() . "/{$arg1}/";
Assertion::file($this->configFilePath . 'configured.json');
$this->config = json_decode(file_get_contents($this->configFilePath . 'configured.json'));
Assertion::isInstanceOf($this->config, 'stdClass');
}
/**
* @param LegDto[] $legs
*/
public function setLegs(array $legs) : array
{
foreach ($legs as $leg) {
Assertion::isInstanceOf($leg, LegDto::class);
}
$this->legs = $legs;
}
/**
* FilesCollection constructor.
*
* @param File[] $files
*/
public function __construct(array $files)
{
foreach ($files as $file) {
Assertion::isInstanceOf($file, File::class);
}
$this->files = $files;
}
/**
* @param CreateCoupon $createCoupon
*/
public function validate(DtoInterface $createCoupon)
{
Assertion::isInstanceOf($createCoupon, 'Matthias\\LeanpubApi\\Dto\\CreateCoupon');
if (count($createCoupon->getPackageDiscounts()) === 0) {
throw new BadRequestException('Coupon should have at least one package discount, one of which can be for the "book" package');
}
}
protected function _validateIpnListeners()
{
Assertion::notEmpty($this->ipnListeners);
foreach ($this->ipnListeners as $ipn_listener) {
Assertion::isInstanceOf($ipn_listener, PaymentListener::class);
}
}
public function fromFileMakerValue($value)
{
if (null === $value) {
return null;
}
Assertion::isInstanceOf($value, StreamInterface::class);
return $value;
}
/**
* @param TaskListId $taskListId
* @param TaskListEntry[] $taskListEntries
*/
private function __construct(TaskListId $taskListId, array $taskListEntries)
{
foreach ($taskListEntries as $taskListEntry) {
Assertion::isInstanceOf($taskListEntry, 'Prooph\\Processing\\Processor\\Task\\TaskListEntry');
}
$this->taskListEntries = $taskListEntries;
$this->taskListId = $taskListId;
}
public function toFileMakerValue($value)
{
if (null === $value) {
return null;
}
Assertion::isInstanceOf($value, Decimal::class);
return $value;
}
/**
* @param Adapter $snapshotAdapter
*/
public function __construct(Adapter $snapshotAdapter, array $aggregateRepositories)
{
foreach ($aggregateRepositories as $aggregateRepository) {
Assertion::isInstanceOf($aggregateRepository, AggregateRepository::class);
}
$this->snapshotAdapter = $snapshotAdapter;
$this->aggregateRepositories = $aggregateRepositories;
}
/**
* @param StreamName $streamName
* @param Message[] $streamEvents
*/
public function __construct(StreamName $streamName, array $streamEvents)
{
foreach ($streamEvents as $streamEvent) {
Assertion::isInstanceOf($streamEvent, Message::class);
}
$this->streamName = $streamName;
$this->streamEvents = $streamEvents;
}
public function fromFileMakerValue($value)
{
if (null === $value) {
return null;
}
Assertion::isInstanceOf($value, Decimal::class);
return $value->asInteger();
}
public function delete($identifier, SettingsInterface $settings = null)
{
$arguments = $settings->get('arguments');
Assertion::isInstanceOf($arguments, SettingsInterface::CLASS);
$exchange = $this->getConfig()->get('exchange');
$channel = $this->connector->getConnection()->channel();
$channel->exchange_unbind($exchange, $exchange, $identifier, false, $arguments->toArray());
}
public function toFileMakerValue($value)
{
if (null === $value) {
return null;
}
Assertion::isInstanceOf($value, DateTimeInterface::class);
return $value;
}
/**
* {@inheritdoc}
*/
public function savePreConfiguredAuthorization(BasePreConfiguredAuthorizationInterface $pre_configured_authorization)
{
Assertion::isInstanceOf($pre_configured_authorization, CurrentPreConfiguredAuthorizationInterface::class);
$hash = $this->calculateHash($pre_configured_authorization->getResourceOwnerPublicId(), $pre_configured_authorization->getClientPublicId(), $pre_configured_authorization->getScopes());
$pre_configured_authorization->setHash($hash);
$this->getEntityManager()->persist($pre_configured_authorization);
$this->getEntityManager()->flush();
}
protected function guardRequiredState()
{
parent::guardRequiredState();
Assertion::regex($this->aggregate_root_type, '#^([a-z][a-z_-]+(?<![_-])\\.){2}[a-z][a-z_-]+(?<![_-])$#');
Assertion::integer($this->seq_number);
Assertion::isInstanceOf($this->embedded_entity_events, EmbeddedEntityEventList::CLASS);
Assertion::regex($this->aggregate_root_identifier, '/[\\w\\.\\-_]{1,128}\\-\\w{8}\\-\\w{4}\\-\\w{4}\\-\\w{4}\\-\\w{12}\\-\\w{2}_\\w{2}\\-\\d+/');
}
private function extractWithMetadata($entity, Entity $metadata) : array
{
if ($entity instanceof ProxyInterface) {
$entity = $entity->__getRealEntity();
}
Assertion::isInstanceOf($entity, $metadata->getClassName());
$data = [];
$reflectionClass = new ReflectionClass($entity);
foreach ($metadata->getFields() as $fieldMetadata) {
if ($fieldMetadata->isReadOnly()) {
continue;
}
$fieldName = $fieldMetadata->getFieldName();
try {
$type = $fieldMetadata->getType();
$value = $this->getProperty($reflectionClass, $entity, $fieldMetadata->getPropertyName());
if (!$fieldMetadata->isRepeatable()) {
$data[$fieldName] = $type->toFileMakerValue($value);
continue;
}
Assertion::isArray($value);
$index = 0;
foreach ($value as $individualValue) {
$data[sprintf('%s(%d)', $fieldName, ++$index)] = $type->toFileMakerValue($individualValue);
}
} catch (Exception $e) {
throw ExtractionException::fromInvalidField($metadata, $fieldMetadata, $e);
}
}
foreach ($metadata->getEmbeddables() as $embeddableMetadata) {
$prefix = $embeddableMetadata->getFieldNamePrefix();
$embeddableData = $this->extractWithMetadata($this->getProperty($reflectionClass, $entity, $embeddableMetadata->getPropertyName()), $embeddableMetadata->getMetadata());
foreach ($embeddableData as $key => $value) {
$data[$prefix . $key] = $value;
}
}
$toOne = array_filter($metadata->getManyToOne(), function (ManyToOne $manyToOneMetadata) {
return !$manyToOneMetadata->isReadOnly();
}) + array_filter($metadata->getOneToOne(), function (OneToOne $oneToOneMetadata) {
return $oneToOneMetadata->isOwningSide() && !$oneToOneMetadata->isReadOnly();
});
foreach ($toOne as $relationMetadata) {
$relation = $this->getProperty($reflectionClass, $entity, $relationMetadata->getPropertyName());
if (null === $relation) {
$data[$relationMetadata->getFieldName()] = null;
continue;
}
if ($relation instanceof ProxyInterface) {
Assertion::isInstanceOf($relation->__getRealEntity(), $relationMetadata->getTargetEntity());
$relationId = $relation->__getRelationId();
} else {
Assertion::isInstanceOf($relation, $relationMetadata->getTargetEntity());
$relationId = $this->getProperty(new ReflectionClass($relation), $relation, $relationMetadata->getTargetPropertyName());
}
$data[$relationMetadata->getFieldName()] = $relationId;
}
return $data;
}
/**
* {@inheritdoc}
*/
public function unbind(string $key, $value) : Data
{
Assertion::isInstanceOf($value, DateTimeInterface::class);
$dateTime = $value->setTimezone($this->timeZone);
if ((int) $dateTime->format('u') > 0) {
return Data::fromFlatArray([$key => $dateTime->format('H:i:s.u')]);
}
return Data::fromFlatArray([$key => $dateTime->format('H:i:s')]);
}
/**
* {@inheritDoc}
*/
public function create($aggregateClass, DomainEventStreamInterface $domainEventStream)
{
$methodCall = sprintf('%s::%s', $aggregateClass, $this->staticConstructorMethod);
Assert::true(method_exists($aggregateClass, $this->staticConstructorMethod), sprintf('NamedConstructorAggregateFactory expected %s to exist', $methodCall));
$aggregate = call_user_func($methodCall);
Assert::isInstanceOf($aggregate, $aggregateClass);
$aggregate->initializeState($domainEventStream);
return $aggregate;
}
/**
* @param string $offset
* @param TechnicalData $value
*/
public function offsetSet($offset, $value)
{
Assertion::isInstanceOf($value, TechnicalData::class);
$name = $value->getName();
if (null !== $offset) {
Assertion::eq($name, $offset);
}
$this->data[$name] = $value;
}
/**
* {@inheritDoc}
*/
public function save(AggregateRoot $aggregate)
{
// maybe we can get generics one day.... ;)
Assert::isInstanceOf($aggregate, $this->aggregateClass);
$domainEventStream = $aggregate->getUncommittedEvents();
$eventStream = $this->decorateForWrite($aggregate, $domainEventStream);
$this->eventStore->append($aggregate->getAggregateRootId(), $eventStream);
$this->eventBus->publish($eventStream);
}
/**
* @inheritdoc
*
* @param ServiceLocatorInterface $serviceLocator
*
* @return BaseReportRepository
* @throws \Assert\AssertionFailedException
* @throws \Zend\ServiceManager\Exception\ServiceNotFoundException
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$appServiceLocator = $serviceLocator instanceof AbstractPluginManager ? $serviceLocator->getServiceLocator() : $serviceLocator;
/** @var ObjectManagerAutoDetectorInterface $objectManagerAutoDetector */
$objectManagerAutoDetector = $appServiceLocator->get(ObjectManagerAutoDetectorInterface::class);
$om = $objectManagerAutoDetector->getObjectManagerByClassName(BaseReport::class);
$rep = $om->getRepository(BaseReport::class);
Assertion::isInstanceOf($rep, BaseReportRepository::class);
return $rep;
}
/**
* @param string $relatedTypeClass
* @param Description $descriptionOfType
* @param PrototypeProperty[] $typeProperties
*/
public function __construct($relatedTypeClass, Description $descriptionOfType, array $typeProperties)
{
Assertion::implementsInterface($relatedTypeClass, 'Prooph\\Processing\\Type\\Type');
foreach ($typeProperties as $propertyOfType) {
Assertion::isInstanceOf($propertyOfType, 'Prooph\\Processing\\Type\\PrototypeProperty');
}
$this->relatedTypeClass = $relatedTypeClass;
$this->descriptionOfType = $descriptionOfType;
$this->typeProperties = $typeProperties;
PrototypeRegistry::registerPrototype($this);
}
public function resolve(Command $command)
{
Assertion::string($command->name(), sprintf('%s::name() should return a string', get_class($command)));
if (!isset($this->commandHandlers[$command->name()])) {
throw new \InvalidArgumentException(sprintf('No valid handler found for command "%s"', $command->name()));
}
$serviceId = $this->commandHandlers[$command->name()];
$commandHandler = call_user_func($this->serviceLocator, $serviceId);
Assertion::isInstanceOf($commandHandler, 'Matthias\\SimpleBus\\Command\\Handler\\CommandHandler');
return $commandHandler;
}
public function __construct($context, $reference, DateTime $start, Kind $kind)
{
Assertion::isInstanceOf($context, 'Bakgat\\Notos\\Domain\\Model\\Identity\\Party');
Assertion::isInstanceOf($reference, 'Bakgat\\Notos\\Domain\\Model\\Identity\\Party');
$this->setContext($context);
$this->setReference($reference);
$this->setStart($start);
$this->setKind($kind);
$this->setCreatedAt(new DateTime());
$this->setUpdatedAt(new DateTime());
}
/**
* @param string $error Short name of the error
* @param string $error_description Description of the error
* @param array $error_data Data to add to the error
* @param array $data Additional data sent to the exception
*/
public function __construct($error, $error_description, array $error_data, array $data)
{
parent::__construct(302, $error, $error_description, $error_data);
Assertion::keyExists($data, 'redirect_uri', 'redirect_uri_not_defined');
Assertion::keyExists($data, 'response_mode', 'invalid_response_mode');
Assertion::isInstanceOf($data['response_mode'], ResponseModeInterface::class, 'invalid_response_mode');
$this->response_mode = $data['response_mode'];
$this->redirect_uri = $data['redirect_uri'];
if (array_key_exists('state', $data) && null !== $data['state']) {
$this->errorData['state'] = $data['state'];
}
}
/**
* @inheritdoc
*/
public function allTrue(array $specs)
{
$allTrue = true;
foreach ($specs as $spec) {
Assertion::isInstanceOf($spec, UserRightSpecInterface::class);
if (!$this->isTrue($spec)) {
$allTrue = false;
break;
}
}
return $allTrue;
}
/**
* @param EventInterface $e
*
* @return array|void
* @throws \Zend\ServiceManager\Exception\ServiceNotFoundException
* @throws \Assert\AssertionFailedException
*/
public function onBootstrap(EventInterface $e)
{
Assertion::isInstanceOf($e, MvcEvent::class);
/** @var MvcEvent $e */
$sm = $e->getApplication()->getServiceManager();
/** @var GoogleClientBuilder $googleClientBuilder */
$googleClientBuilder = $sm->get(GoogleClientBuilder::class);
Assertion::isInstanceOf($googleClientBuilder, GoogleClientBuilder::class);
/** @var AccessTokenFromConsole $accessTokenFromConsole */
$accessTokenFromConsole = $sm->get(AccessTokenFromConsole::class);
Assertion::isInstanceOf($accessTokenFromConsole, AccessTokenFromConsole::class);
$googleClientBuilder->getEventManager()->attachAggregate($accessTokenFromConsole);
}