public function validation($ruleName, $value)
 {
     Cascade::getLogger('bigc\\profile')->debug("ProfileData validation {$ruleName}, {$value}");
     try {
         $this->validRule[$ruleName]->assert($value);
     } catch (\Respect\Validation\Exceptions\NestedValidationException $ex) {
         $e = new \InvalidArgumentException($this->validMessage[$ruleName], 0, $ex);
         Cascade::getLogger('bigc\\profile')->warning($e->getMessage());
         throw $e;
     }
     return true;
 }
Example #2
0
 /**
  * @covers Gloubster\Server\GloubsterServer::throwError
  */
 public function testThrowError()
 {
     $server = $this->getServer();
     $exception = new \InvalidArgumentException('SHIT');
     $server['monolog']->expects($this->once())->method('addError')->with($this->equalTo($exception->getMessage()));
     try {
         $server->throwError($exception);
         $this->fail('Should have raised an exception');
     } catch (\Exception $e) {
         $this->assertEquals($exception, $e);
     }
 }
 public function __construct($message, array $errors, Exception $previous = null)
 {
     $flatErrors = iterator_to_array(new RecursiveIteratorIterator(new RecursiveArrayIterator($errors)), false);
     $message = $message . ":\n" . implode("\n", $flatErrors);
     parent::__construct($message, 0, $previous);
     $this->setErrors($errors);
 }
 /**
  * @param string|WeaponlikeCode $message
  * @param int $code
  * @param \Exception $previous
  */
 public function __construct($message = '', $code = 0, \Exception $previous = null)
 {
     if ($message instanceof WeaponlikeCode) {
         $message = "Given weapon-like '{$message}' is of unknown type";
     }
     parent::__construct($message, $code, $previous);
 }
 /**
  * Constructor.
  *
  * @param mixed        $value
  * @param string|array $expectedType
  */
 public function __construct($value, $expectedType)
 {
     if (is_array($expectedType)) {
         $expectedType = implode('", "', $expectedType);
     }
     parent::__construct(sprintf('Expected argument of type "%s", "%s" given', $expectedType, is_object($value) ? get_class($value) : gettype($value)));
 }
 private function init($fileName)
 {
     if (!file_exists($fileName)) {
         throw InvalidArgumentException::fileNotExists($fileName);
     }
     $this->fileName = $fileName;
 }
 public function __construct(\ReflectionParameter $parameter, $message = null, $code = null, \Exception $previous = null)
 {
     if (null === $message) {
         $message = sprintf('Unable to resolve argument $%s (#%d) of %s.', $parameter->name, $parameter->getPosition(), static::getFunctionName($parameter->getDeclaringFunction()));
     }
     parent::__construct($message, $code, $previous);
 }
 /**
  * @inheritdoc
  */
 public function __construct($message = '', $code = 0, \Exception $previous = null)
 {
     if (empty($message)) {
         $message = 'Invalid argument value.';
     }
     parent::__construct($message, $code, $previous);
 }
 /**
  * @param string $message
  * @param \Exception $previous
  */
 public function __construct($message = null, \Exception $previous = null)
 {
     if (empty($message)) {
         $message = 'Listeners must implements EventListenerInterface';
     }
     parent::__construct($message, $previous);
 }
 /**
  * {@inheritdoc}
  */
 public function __construct($inputCurrency, $allowedCurrencies = null)
 {
     if (null === $allowedCurrencies) {
         $allowedCurrencies = Environment::$ALLOWED_CURRENCIES;
     }
     parent::__construct(sprintf('Invalid currency given (%s), allowed: %s', $inputCurrency, implode(', ', $allowedCurrencies)));
 }
 public function __construct($fileName)
 {
     if (!file_exists($fileName)) {
         throw InvalidArgumentException::fileNotExists($fileName);
     }
     $this->fileName = $fileName;
 }
Example #12
0
 public function __construct($message = "", $code = 0, Exception $previous = null)
 {
     if (empty($message)) {
         $message = 'The specified file pointer is not a valid stream resource';
     }
     parent::__construct($message, $code, $previous);
 }
Example #13
0
 public function __construct($file, $line, $message)
 {
     parent::__construct();
     $this->file = $file;
     $this->line = $line;
     $this->message = $message;
 }
 public function __construct($message = null)
 {
     if ($message === null) {
         $message = 'The parameter must be a non empty string';
     }
     parent::__construct($message);
 }
 public function __construct($name, $value, $expected)
 {
     if (!is_string($name)) {
         throw new InvalidArgumentException("Not a string: name");
     }
     if (!is_string($expected)) {
         throw new InvalidArgumentException("Not a string: expected");
     }
     $lead = "Invalid";
     if (NULL === $value) {
         $lead = "Not set";
     }
     $type = gettype($value);
     $got_msg = $type;
     if (is_object($value)) {
         $class = get_class($value);
         $got_msg = "{$type} ({$class})";
     }
     $this->name = $name;
     $this->type = $type;
     $this->expected = $expected;
     $this->message = $msg;
     $msg = "{$lead}: {$name} - Got: {$got_msg} - Expected: {$expected}";
     parent::__construct($msg, 0);
 }
 public function __construct($message = null)
 {
     if (null === $message) {
         $message = t('Соединение с БД не установлено.');
     }
     return parent::__construct($message);
 }
Example #17
0
 /**
  * This function instantiates the exception with the specified message,
  * variables, and code.
  *
  * @access public
  * @param string $message                        the message
  * @param array $variables                       the variables
  * @param integer $code                          the code
  * @return Throwable_InvalidArgument_Exception   the exception
  */
 public function __construct($message, array $variables = NULL, $code = 0)
 {
     // Set the message
     $message = __($message, $variables);
     // Pass the message to the parent
     parent::__construct($message, $code);
 }
Example #18
0
 public function __construct($message = "", $code = 500, Exception $previous = null)
 {
     if (empty($message)) {
         $message = \JText::_('LIB_FOF_MODEL_ERR_FILTER_INVALIDFIELD');
     }
     parent::__construct($message, $code, $previous);
 }
 /**
  * Constructor.
  *
  * @param string $name
  * @param array  $alternatives
  */
 public function __construct($name, array $alternatives = array())
 {
     $this->name = $name;
     $this->alternatives = $alternatives;
     parent::__construct('');
     $this->update();
 }
 /**
  * Construct the exception with a type.
  * Use type from self constants.
  *
  * @param string     $type
  * @param int        $code
  * @param \Exception $previous
  */
 public function __construct($type, $code = 0, \Exception $previous = null)
 {
     if ($type != self::ROW || $type != self::COLUMN) {
         throw new parent(sprintf("Type must be %s or %s.", self::ROW, self::COLUMN));
     }
     parent::__construct(sprintf("%s number must be lower or equal than max %s number -1 and higher or equal than Zero.", lcfirst($type), $type), $code, $previous);
 }
Example #21
0
 /**
  * @param mixed $value
  * @param string Field $field
  * @param string $message
  */
 public function __construct($value, Field $field, $message = null)
 {
     $this->value = $value;
     $this->field = $field;
     $message = sprintf('Failed to encode [%s] for field [%s].  Detail: %s', is_scalar($this->value) ? $this->value : StringUtils::varToString($this->value), $this->field->getName(), $message);
     parent::__construct($message);
 }
Example #22
0
 /**
  * @param CountryCode $countryCode
  * @param string $countryName
  */
 public function __construct(CountryCode $countryCode, $countryName)
 {
     if (!is_string($countryName)) {
         throw InvalidArgumentException::invalidType('string', 'countryName', $countryName);
     }
     $this->countryCode = $countryCode;
     $this->countryName = $countryName;
 }
 public function __construct($message = null, $code = 0, \Exception $previous = null, $httpStatus = 500, $details = null)
 {
     $this->_httpStatus = $httpStatus;
     if ($details !== null) {
         $this->_details = $details;
     }
     parent::__construct($message, $code, $previous);
 }
 public function __toString()
 {
     $str = parent::__toString();
     if ($this->_fileType) {
         $str .= "\nFile type: " . $this->_fileType;
     }
     return $str;
 }
Example #25
0
 /**
  * @param string $territory_code
  * @param null $message
  * @param int $code
  * @param \Exception|null $previous
  */
 public function __construct($territory_code, $message = null, $code = 500, \Exception $previous = null)
 {
     $this->territory_code = $territory_code;
     if (!$message) {
         $message = "Territory not defined for code: {$territory_code}.";
     }
     parent::__construct($message, $code, $previous);
 }
 /**
  * Constructor.
  *
  * @param string $key       The requested parameter key
  * @param string $sourceId  The service id that references the non-existent parameter
  * @param string $sourceKey The parameter key that references the non-existent parameter
  */
 public function __construct($key, $sourceId = null, $sourceKey = null, \Exception $previous = null)
 {
     $this->key = $key;
     $this->sourceId = $sourceId;
     $this->sourceKey = $sourceKey;
     parent::__construct('', 0, $previous);
     $this->updateRepr();
 }
 /**
  * @param string $type Type name
  * @param array $native Supported native types
  * @param \Exception $previous
  */
 public function __construct($type, array $native = array(), \Exception $previous = null)
 {
     $message = sprintf('No class or interface called "%s" exists', $type);
     if (!empty($native)) {
         $message .= sprintf('. Supported native types: %s', implode(', ', $native));
     }
     parent::__construct($message, 0, $previous);
 }
 /**
  * InvalidArgumentException constructor.
  *
  * @param string $argumentName The name of the invalid argument that caused the exception
  * @param string $expected The expected type of the invalid argument
  * @param string $actual The actual type of the invalid argument that has been given
  * @param string $previous The previous exception, if any
  */
 public function __construct($argumentName, $expected, $actual, $previous = null)
 {
     $this->setArgumentName($argumentName);
     $this->setExpected($expected);
     $this->setActual($actual);
     $this->setMessage();
     parent::__construct($this->message, $this->code, $previous);
 }
 /**
  * Constructor.
  *
  * @param string     $key          The requested parameter key
  * @param string     $sourceId     The service id that references the non-existent parameter
  * @param string     $sourceKey    The parameter key that references the non-existent parameter
  * @param \Exception $previous     The previous exception
  * @param string[]   $alternatives Some parameter name alternatives
  */
 public function __construct($key, $sourceId = null, $sourceKey = null, \Exception $previous = null, array $alternatives = array())
 {
     $this->key = $key;
     $this->sourceId = $sourceId;
     $this->sourceKey = $sourceKey;
     $this->alternatives = $alternatives;
     parent::__construct('', 0, $previous);
     $this->updateRepr();
 }
 public function __construct($message, $code, $propertyPath = null, $value, array $constraints = array())
 {
     parent::__construct($message, $code);
     $this->propertyPath = $propertyPath;
     $this->value = $value;
     $this->constraints = $constraints;
 }