protected function guardRequiredState() { parent::guardRequiredState(); Assertion::regex($this->projection_type, '#^([a-z][a-z_-]+(?<!_-)\\.){2}[a-z][a-z_]+(?<!_)::projection\\.[a-z][a-z_]+(?<!_)$#'); Assertion::isArray($this->data); Assertion::regex($this->projection_identifier, '/[\\w\\.\\-_]{1,128}\\-\\w{8}\\-\\w{4}\\-\\w{4}\\-\\w{4}\\-\\w{12}\\-\\w{2}_\\w{2}\\-\\d+/'); }
/** * {@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()); }
/** * @return \Jose\Object\JWKInterface[] */ public function getKeys() { $content = json_decode($this->getContent(), true); Assertion::isArray($content, 'Invalid content.'); Assertion::keyExists($content, 'keys', 'Invalid content.'); return (new JWKSet($content))->getKeys(); }
private function validate() { Assertion::keyExists($this->options, 'packages'); Assertion::isArray($this->options['packages']); Assertion::keyExists($this->options, 'rooms'); Assertion::isArray($this->options['rooms']); }
public static function deserialize($data) { Assertion::isArray($data); $entities = array_map(function ($entity) { return Entity::deserialize($entity); }, $data); return new self($entities); }
/** * Create a new value object * @param array $value */ public function __construct($value) { Assertion::isArray($value); foreach ($value as $object) { Assertion::implementsInterface($object, EventInterface::class); } $this->value = SplFixedArray::fromArray($value); }
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 check(ClientInterface $client, array $registration_parameters) { if (!array_key_exists('request_uris', $registration_parameters)) { return; } Assertion::isArray($registration_parameters['request_uris'], 'The parameter "request_uris" must be a list of URI.'); Assertion::allUrl($registration_parameters['request_uris'], 'The parameter "request_uris" must be a list of URI.'); $client->set('request_uris', $registration_parameters['request_uris']); }
/** * Create a new immutable Body instance * * @param string $route * @param string $signature * @param array $data * @return void */ public function __construct($route, $signature, $data) { Assertion::url($route); Assertion::string($signature); Assertion::isArray($data); $this->route = $route; $this->signature = $signature; $this->data = $data; }
/** * @param string $uri * * @throws \InvalidArgumentException * * @return \OTPHP\TOTP|\OTPHP\HOTP */ public static function loadFromProvisioningUri($uri) { $parsed_url = parse_url($uri); Assertion::isArray($parsed_url, 'Not a valid OTP provisioning URI'); self::checkData($parsed_url); $otp = self::createOTP($parsed_url); self::populateOTP($otp, $parsed_url); return $otp; }
/** * @param array $taskData * @return static */ public static function reconstituteFromArray(array $taskData) { Assertion::keyExists($taskData, 'target'); Assertion::keyExists($taskData, 'allowed_types'); Assertion::keyExists($taskData, 'preferred_type'); Assertion::keyExists($taskData, 'metadata'); Assertion::isArray($taskData['allowed_types']); return new self($taskData['target'], $taskData['allowed_types'], $taskData['preferred_type'], $taskData['metadata']); }
protected function guardRequiredState() { parent::guardRequiredState(); Assertion::string($this->parent_attribute_name); Assertion::string($this->embedded_entity_type); Assertion::uuid($this->embedded_entity_identifier); Assertion::isArray($this->embedded_entity_events); Assertion::isArray($this->data); }
/** * {@inheritdoc} */ public function checkHeader(array $protected_headers, array $headers, array $checked_claims) { if (!array_key_exists('crit', $protected_headers)) { return; } Assertion::isArray($protected_headers['crit'], 'The parameter "crit" must be a list.'); $diff = array_diff($protected_headers['crit'], $checked_claims); Assertion::true(empty($diff), sprintf('One or more claims are marked as critical, but they are missing or have not been checked (%s).', json_encode(array_values($diff)))); }
public function unbind($value) : Data { Assertion::isArray($value); $data = Data::none(); foreach ($value as $index => $individualValue) { $data = $data->merge($this->wrappedMapping->withPrefixAndRelativeKey($this->key, (string) $index)->unbind($individualValue)); } return $data; }
protected function guardRequiredState() { parent::guardRequiredState(); Assertion::isArray($this->data); $mandatory_attribute_names = ['identifier', 'uuid', 'language', 'version', 'workflow_state']; foreach ($mandatory_attribute_names as $attribute_name) { Assertion::keyExists($this->data, $attribute_name, 'mandatory'); } }
/** * {@inheritdoc} */ public function identify($subject) { Assertion::isArray($subject); Assertion::notEmptyKey($subject, 'username'); if (!in_array($subject['username'], $this->userKeys)) { throw new IdentificationFailed('User not found'); } $id = array_search($subject['username'], $this->userKeys); return new User($id, $this->users[$id]); }
public function __construct($name, $slug) { Assertion::string($name); Assertion::isArray($slug); $this->setName($name); $this->setSlug($slug); $this->setCreatedAt(new DateTime()); $this->setUpdatedAt(new DateTime()); $this->roles = new ArrayCollection(); $this->users = new ArrayCollection(); }
/** * @param string $workflowId * @param array $startMessage * @param string $firstMessageHandlerId * @return ScheduleFirstTasksForWorkflow */ public static function withData($workflowId, $startMessage, $firstMessageHandlerId) { Assertion::uuid($workflowId); Assertion::uuid($firstMessageHandlerId); Assertion::isArray($startMessage); Assertion::keyExists($startMessage, 'message_type'); Assertion::keyExists($startMessage, 'processing_type'); $processingType = $startMessage['processing_type']; Assertion::implementsInterface($processingType, Type::class); return new self(__CLASS__, ['workflow_id' => $workflowId, 'start_message' => $startMessage, 'first_message_handler' => $firstMessageHandlerId]); }
/** * @param array $taskListArr * @return TaskList */ public static function fromArray(array $taskListArr) { Assertion::keyExists($taskListArr, 'taskListId'); Assertion::keyExists($taskListArr, 'entries'); Assertion::isArray($taskListArr['entries']); $taskListId = TaskListId::fromString($taskListArr['taskListId']); $entries = []; foreach ($taskListArr['entries'] as $entryArr) { $entries[] = TaskListEntry::fromArray($entryArr); } return self::fromTaskListEntries($taskListId, $entries); }
/** * Retrieves exchange rates from http://fixer.io * * @param Currency $currency */ private function retrieveExchangeRateFor(Currency $currency) { $response = $this->client->request('GET', self::EXCHANGE_RATE_API_URL . '/latest', ['query' => ['base' => $this->baseCurrency->getName()]]); Assert::same($response->getStatusCode(), 200); $rawExchangeRates = $response->getBody(); $exchangeRates = json_decode($rawExchangeRates, true); Assert::isArray($exchangeRates); Assert::keyExists($exchangeRates, 'rates'); Assert::keyExists($exchangeRates['rates'], $currency->getName()); Assert::numeric($exchangeRates['rates'][$currency->getName()]); $this->exchangeRates[$currency->getName()] = $exchangeRates['rates'][$currency->getName()]; }
/** * @param string $uri The URI * @param array $params Parameters added to the URI * * @throws \InvalidArgumentException * * @return string */ public static function buildURI($uri, $params = []) { $parse_url = parse_url($uri); Assertion::isArray($parse_url, 'The argument is not a valid URI.'); foreach ($params as $k => $v) { if (isset($parse_url[$k])) { $parse_url[$k] .= '&' . http_build_query($v); } else { $parse_url[$k] = http_build_query($v); } } return self::buildScheme($parse_url) . self::buildUserAuthentication($parse_url) . self::buildHost($parse_url) . self::buildPort($parse_url) . self::buildPath($parse_url) . self::buildQuery($parse_url) . self::buildFragment($parse_url); }
/** * Retrieves exchange rates from http://free.currencyconverterapi.com * * @param Currency $currency */ private function retrieveExchangeRateFor(Currency $currency) { $conversion = sprintf('%s_%s', $currency->getName(), $this->baseCurrency->getName()); $response = $this->client->request('GET', self::EXCHANGE_RATE_API_URL . '/api/v3/convert', ['query' => ['q' => $conversion]]); Assert::same($response->getStatusCode(), 200); $rawExchangeRates = $response->getBody(); $exchangeRates = json_decode($rawExchangeRates, true); Assert::isArray($exchangeRates); Assert::keyExists($exchangeRates, 'results'); Assert::keyExists($exchangeRates['results'], $conversion); Assert::keyExists($exchangeRates['results'][$conversion], 'val'); Assert::numeric($exchangeRates['results'][$conversion]['val']); $this->exchangeRates[$currency->getName()] = (double) $exchangeRates['results'][$conversion]['val']; }
public function scrollStart($query, $cursor = null) { Assertion::isArray($query); $query['index'] = $this->getIndex(); $query['type'] = $this->getType(); $query['scroll'] = $this->config->get('scroll_timeout', '1m'); $query['sort'] = ['_doc']; if ($this->config->get('log_scroll_query', false) === true) { $this->logger->debug('[' . __METHOD__ . '] scroll start = ' . json_encode($query, JSON_PRETTY_PRINT)); } // Elasticsearch returns results on scroll start $raw_result = $this->connector->getConnection()->search($query); return new FinderResult($this->mapResultData($raw_result), $raw_result['hits']['total'], 0, $raw_result['_scroll_id']); }
/** * @return \Jose\Object\JWKInterface[] */ public function getKeys() { $content = json_decode($this->getContent(), true); Assertion::isArray($content, 'Invalid content.'); $jwkset = new JWKSet(); foreach ($content as $kid => $cert) { $jwk = KeyConverter::loadKeyFromCertificate($cert); Assertion::notEmpty($jwk, 'Invalid content.'); if (is_string($kid)) { $jwk['kid'] = $kid; } $jwkset->addKey(new JWK($jwk)); } return $jwkset->getKeys(); }
/** * Submit constructor. * @param array $url * @param string $label * @param string $method * @param array $configurableOptions */ public function __construct($url, $label = 'Submit', $method = 'post', array $configurableOptions = []) { Assertion::string($method); $configurableOptions['url'] = $url; $configurableOptions['label'] = $label; $configurableOptions['method'] = $method; $this->configurableOptions[] = 'hiddenFields'; if (array_key_exists('hiddenFields', $configurableOptions)) { Assertion::isArray($configurableOptions['hiddenFields']); } parent::__construct($configurableOptions); // add csrf token ? if (function_exists('csrf_token')) { $this->hiddenFields['_token'] = csrf_token(); } }
/** * Constructor. * * @param bool $verified * @param \DateTimeImmutable|null $createdAt * @param Photo\Photo $bestPhoto * @param float|null $rating * @param string|null $url * @param int|null $hereNow * @param string[] $tags * @param int|null $likes * @param \DateTimeZone|null $timeZone */ public function __construct($verified, \DateTimeImmutable $createdAt = null, Photo\Photo $bestPhoto = null, $rating = null, $url = null, $hereNow = null, $tags = [], $likes = null, \DateTimeZone $timeZone = null) { Assertion::boolean($verified); Assertion::isArray($tags); Assertion::nullOrInteger($likes); Assertion::nullOrFloat($rating); Assertion::nullOrString($url); Assertion::nullOrInteger($hereNow); $this->verified = $verified; $this->rating = $rating; $this->hereNow = $hereNow; $this->url = $url; $this->createdAt = $createdAt; $this->timeZone = $timeZone; $this->bestPhoto = $bestPhoto; $this->tags = $tags; $this->likes = $likes; }
/** * create an array of tokens to be used in various column functions. if the * data passed is an object, it will first see if the object has a method called * isArray() to create an array from the object, otherwise it will cast the object * to an array and hope for the best * @param $data */ public function createTokens($data) { if (isset($this->tokens)) { return $this->tokens; } if (is_object($data) && method_exists($data, 'toArray')) { $data = $data->toArray(); } Assertion::isArray($data); // drop any object members. $data = array_filter($data, function ($v) { return !is_object($v); }); // allow for tokens to access multi-dimensional arrays via dot syntax $data = array_dot($data); foreach ($data as $key => $value) { $this->tokens['{' . $key . '}'] = $value; } }
/** * @param \OAuth2\Client\ClientInterface $client * @param array $registration_parameters */ private function checkResponseTypes(ClientInterface $client, array $registration_parameters) { Assertion::isArray($registration_parameters['response_types'], 'The parameter "response_types" must be an array of strings.'); Assertion::allString($registration_parameters['response_types'], 'The parameter "grant_types" must be an array of strings.'); foreach ($registration_parameters['response_types'] as $response_type) { $types = $this->getResponseTypeManager()->getResponseTypes($response_type); if (!in_array($response_type, $client->get('response_types'))) { $response_types = $client->get('response_types'); $response_types[] = $response_type; $client->set('response_types', $response_types); } foreach ($types as $type) { $associated_grant_types = $type->getAssociatedGrantTypes(); $diff = array_diff($associated_grant_types, $registration_parameters['grant_types']); Assertion::true(empty($diff), sprintf('The response type "%s" is associated with the grant types "%s" but this response type is missing.', $type->getResponseType(), json_encode($diff))); $client->set('grant_types', array_unique(array_merge($client->get('grant_types'), $associated_grant_types))); } } }
/** * {@inheritdoc} */ public static function createFromResponse(ResponseInterface $response) { $content = $response->getBody()->getContents(); $json = json_decode($content, true); Assertion::isArray($json, 'The response is not a valid OAuth2 Response.'); if (array_key_exists('error', $json)) { $class = Error::class; } elseif (array_key_exists('access_token', $json)) { $class = AccessToken::class; } else { throw new \InvalidArgumentException('Unsupported response.'); } /** * @var self */ $object = new $class(); $object->values = $json; return $object; }
/** * @param array $data * * @internal param GitLabDto $hydratedObject * * @return OAuthDto * @throws \Assert\AssertionFailedException */ protected function getAuthFromData(array $data) { Assertion::keyExists($data, 'auth'); Assertion::keyExists($data, 'authData'); Assertion::isArray($data['authData']); $authUuid = $data['auth']; unset($data['auth']); $auth = null; foreach ($data['authData'] as $authDataItem) { Assertion::isInstanceOf($authDataItem, OAuthDto::class); /** @var OAuthDto $authDataItem*/ if ($authUuid === $authDataItem->getId()) { $auth = $authDataItem; break; } } Assertion::isInstanceOf($auth, OAuthDto::class); return $auth; }