public function execute(&$value, &$error)
{
$class_name = $this->getParameter('class_name');
$field_const_name = $this->getParameter('field_const_name');
$form_field_name = $this->getParameter('form_field_name');
$form_field_value = $this->getContext()->getRequest()->getParameter($form_field_name);
$form_id_name = $this->getParameter('form_id_name');
if ($form_id_name) {
$form_id_value = $this->getContext()->getRequest()->getParameter($form_id_name);
}
$class = new ReflectionClass($class_name);
if ($class->hasConstant($field_const_name)) {
$criteria = new Criteria();
$criteria->add($class->getConstant($field_const_name), $form_field_value);
if (isset($form_id_value) && $form_id_value && $class->hasConstant('ID')) {
$criteria->add($class->getConstant('ID'), $form_id_value, Criteria::NOT_EQUAL);
}
if ($class->hasMethod('doSelectOne')) {
$ref_method = $class->getMethod('doSelectOne');
$object = $ref_method->invoke(null, $criteria);
if (!$object) {
return true;
}
}
sfContext::getInstance()->getLogger()->info('Buraya geldi');
}
$error = $this->getParameter('unique_error');
return false;
}
/**
* @param \SplFileInfo[] $templates
* @param $resourcesPath
* @param $moduleCode
* @throws \Exception
* @throws \SmartyException
*/
protected function processModule($templates, $resourcesPath, $modulePath, $moduleCode)
{
foreach ($templates as $template) {
$fileName = str_replace("__MODULE__", $moduleCode, $template->getFilename());
$fileName = str_replace("FIX", "", $fileName);
$relativePath = str_replace($resourcesPath, "", $template->getPath() . DS);
$completeFilePath = $modulePath . $relativePath . DS . $fileName;
$isFix = false !== strpos($template->getFilename(), "FIX");
// Expect special rule for Module\Module
$isModuleClass = $modulePath . $relativePath . DS . $moduleCode . ".php" === $completeFilePath;
if ($isFix && !file_exists($completeFilePath) || !$isFix) {
if ($isModuleClass && is_file($completeFilePath)) {
$caught = false;
try {
$reflection = new \ReflectionClass("{$moduleCode}\\{$moduleCode}");
} catch (\ReflectionException $e) {
$caught = true;
// The class is not valid
}
if (!$caught && $reflection->hasConstant("MESSAGE_DOMAIN")) {
continue;
// If the class already have the constant, don't override it
}
}
$fetchedTemplate = $this->parser->fetch($template->getRealPath());
$this->writeFile($completeFilePath, $fetchedTemplate, true, true);
}
}
}
protected static function getClassAnnotation(ReflectionClass $reflector, $name)
{
if ($reflector->hasConstant($name)) {
return $reflector->getConstant($name);
}
return null;
}
/**
* Constructor. By passing needed values in constructor, you can quickly contruct instances of FormField in one line of code.
*
* @param string $name Field name
* @param string $field_type Field type. Must be a member of FORM_FIELD_TYPE
* @param string $title Field title as it will appear on the form
* @param bool $isrequired Either field must be filled by the user.
* @param array $options Flat key=>value array to draw SELECT HTML control values. Only applicable if FormFieldType is FORM_FIELD_TYPE::SELECT
* @param string $default_value Default value that will be in the field when form is drawn.
* @param string $value Filed Value. The same as default_value
* @param string $hint Inline help that will appear as yellow hint after the field.
*/
public function __construct($name, $field_type, $title, $isrequired = false, $options = array(), $default_value = null, $value = null, $hint = null, $allow_multiple_choice = false)
{
// Defalts if we blindly pass nullz
if ($options == null) {
$options = array();
}
if ($isrequired == null) {
$isrequired = false;
}
// Validation
// type
$Reflect = new ReflectionClass("FORM_FIELD_TYPE");
if (!$Reflect->hasConstant(strtoupper($field_type))) {
throw new Exception("field_type must be of type FORM_FIELD_TYPE");
}
$this->Name = $name;
$this->FieldType = $field_type;
$this->Title = $title;
$this->DefaultValue = $default_value;
if ($allow_multiple_choice) {
$this->Value = explode(",", $value);
} else {
$this->Value = $value;
}
$this->IsRequired = $isrequired;
$this->Hint = $hint;
$this->Options = $options;
$this->AllowMultipleChoice = $allow_multiple_choice;
}
/**
* Get variant of ENUM value
*
* @param string $enumConst ENUM value
* @param string|null $enumType ENUM type
*
* @throws EnumTypeIsNotRegisteredException
* @throws NoRegisteredEnumTypesException
* @throws ConstantIsFoundInFewRegisteredEnumTypesException
* @throws ConstantIsNotFoundInAnyRegisteredEnumTypeException
*
* @return string
*/
public function getEnumValue($enumConst, $enumType = null)
{
if (!empty($this->registeredEnumTypes) && is_array($this->registeredEnumTypes)) {
// If ENUM type was set, e.g. {{ player.position|readable('BasketballPositionType') }}
if (!empty($enumType)) {
if (!isset($this->registeredEnumTypes[$enumType])) {
throw new EnumTypeIsNotRegisteredException(sprintf('ENUM type "%s" is not registered', $enumType));
}
return constant($this->registeredEnumTypes[$enumType] . '::' . $enumConst);
} else {
// If ENUM type wasn't set, e.g. {{ player.position|readable }}
$occurrences = [];
// Check if value exists in registered ENUM types
foreach ($this->registeredEnumTypes as $registeredEnumType) {
$refl = new \ReflectionClass($registeredEnumType);
if ($refl->hasConstant($enumConst)) {
$occurrences[] = $registeredEnumType;
}
}
// If found only one occurrence, then we know exactly which ENUM type
if (count($occurrences) == 1) {
$enumClassName = array_pop($occurrences);
return constant($enumClassName . '::' . $enumConst);
} elseif (count($occurrences) > 1) {
throw new ConstantIsFoundInFewRegisteredEnumTypesException(sprintf('Constant "%s" is found in few registered ENUM types. You should manually set the appropriate one', $enumConst));
} else {
throw new ConstantIsNotFoundInAnyRegisteredEnumTypeException(sprintf('Constant "%s" wasn\'t found in any registered ENUM type', $enumConst));
}
}
} else {
throw new NoRegisteredEnumTypesException('There are no registered ENUM types');
}
}
/**
*/
public function testAddConstant()
{
$prop = new ReflectionConstant('test', "value");
$this->assertFalse($this->object->hasConstant('test'));
$this->object->addConstant($prop);
$this->assertTrue($this->object->hasConstant('test'));
}
/**
* Convert packable object to an array.
*
* @param PackableInterface $object
* @return array
*/
public static function pack(PackableInterface $object)
{
$reflect = new \ReflectionClass(get_class($object));
$data = array();
foreach ($object as $key => $value) {
// we don't want to send null variables
if ($value === null) {
continue;
}
// run the packer over packable objects
if ($value instanceof PackableInterface) {
$value = self::pack($value);
}
// find packing strategy
$strategy = sprintf('%s_PACKER_STRATEGY', $key);
$strategy = $reflect->hasConstant($strategy) ? $reflect->getConstant($strategy) : self::SINGLE_KEY_STRATEGY;
// execute
$strategy::pack($data, $key, $value);
}
// default actions
foreach ($data as $key => $value) {
// make sure all objects have been packed
if ($value instanceof PackableInterface) {
$value = self::pack($value);
}
// compress any remaining data structures
if (is_array($value)) {
Compress::pack($data, $key, $value);
}
}
return $data;
}
public function testGeneratePostActivation()
{
// Touch a new "insert.sql" file and copy a "create.sql" file
/** @var \org\bovigo\vfs\vfsStreamFile $file */
$configDir = $this->stream->getChild("Config");
$file = vfsStream::newFile("create.sql")->at($configDir);
$file->setContent(file_get_contents(__DIR__ . "/../" . static::TEST_MODULE_PATH . "Config" . DS . "thelia.sql"));
vfsStream::newFile("insert.sql")->at($configDir);
// Then run the generator
$generator = new ModulePhpGenerator($this->getSmarty());
$generator->doGenerate($this->event);
// Read the class
include $this->getStreamPath("TheliaStudioTestModule.php");
$reflection = new \ReflectionClass("TheliaStudioTestModule\\TheliaStudioTestModule");
$this->assertTrue($reflection->hasConstant("MESSAGE_DOMAIN"));
$this->assertEquals("theliastudiotestmodule", $reflection->getConstant("MESSAGE_DOMAIN"));
$this->assertTrue($reflection->hasMethod("postActivation"));
// get a method closure
$method = $reflection->getMethod("postActivation");
$closure = $method->getClosure($reflection->newInstance());
// Test that the table doesn't exist
/** @var \Propel\Runtime\DataFetcher\PDODataFetcher $stmt */
$stmt = $this->con->query("SHOW TABLES LIKE 'example_table'");
$this->assertEquals(0, $stmt->count());
// Execute the method
$closure($this->con);
// Now it exists
/** @var \Propel\Runtime\DataFetcher\PDODataFetcher $stmt */
$stmt = $this->con->query("SHOW TABLES LIKE 'example_table'");
$this->assertEquals(1, $stmt->count());
}
public static function __callStatic($name, $arguments)
{
$reflectionClass = new \ReflectionClass(get_called_class());
if (!$reflectionClass->hasConstant($name)) {
throw new InvalidKey($name);
}
return new static($reflectionClass->getConstant($name), false);
}
/**
* Static factory (ex. ExampleEnum::ONE())
*
* @param $method
* @param $arguments
*
* @throws \BadMethodCallException When given constant is undefined
*
* @return Enum
*/
public static function __callStatic($method, $arguments)
{
$class = get_called_class();
$refl = new \ReflectionClass($class);
if (!$refl->hasConstant($method)) {
throw new \BadMethodCallException(sprintf('Undefined class constant "%s" in "%s"', $method, $class));
}
return new static($refl->getConstant($method), false);
}
/**
* @param string|object $class
* @param string $prefix
* @return array
* @throws \Exception
*/
function getConstantWithPrefixForChoice($class, $prefix, $value)
{
$reflection = new \ReflectionClass($class);
$labelPrefixConstantName = 'LABELPREFIX_' . rtrim($prefix, '_');
if (!$reflection->hasConstant($labelPrefixConstantName)) {
throw new \Exception(sprintf('A constant with name: %s is needed as labelprefix', $labelPrefixConstantName));
}
$labelPrefix = $reflection->getConstant($labelPrefixConstantName);
return $labelPrefix . $value;
}
public function instantiate($className, array $constructorArgs)
{
$class = new \ReflectionClass($this->qualifyClassName($className));
array_unshift($constructorArgs, $this->dataStore);
$newClass = $class->newInstanceArgs($constructorArgs);
if ($class->hasConstant("CUSTOM_DATA")) {
$newClass->customData;
}
return $newClass;
}
public static function GetValue($class_name, $key)
{
//property_exists
$ReflectionClassThis = new ReflectionClass($class_name);
if ($ReflectionClassThis->hasConstant($key)) {
return $ReflectionClassThis->getConstant($key);
} else {
throw new Exception(sprintf(_("Called %s::GetValue('%s') for non-existent property %s"), $class_name, $key, $key));
}
}
/**
* {@inheritdoc}
*/
public function on($class, ...$args)
{
$reflection = new \ReflectionClass($class);
if (false === $reflection->hasConstant('NAME')) {
throw new Exception\InvalidEventNameException($class);
}
if (false === $reflection->isSubclassOf(EventInterface::class)) {
throw new Exception\EventInterfaceImplementationException($class);
}
$this->push(['class' => $class, 'args' => $args]);
}
public static function table($name)
{
$name = strtoupper($name);
$ret = self::$prefix . '_';
$reflection = new \ReflectionClass(__CLASS__);
if ($reflection->hasConstant($name)) {
return strtolower($ret . $reflection->getConstant($name));
} else {
return strtolower($ret . $name);
}
}
/**
* @param int $statusCode
* @return string
* @throws \Exception
*/
protected static function getStatusMessage($statusCode)
{
static $reflectionResponse;
if (null === $reflectionResponse) {
$responseClass = 'Saxulum\\HttpClient\\Response';
$reflectionResponse = new \ReflectionClass($responseClass);
}
$constantName = self::getCodeConstantName($statusCode);
if (!$reflectionResponse->hasConstant($constantName)) {
throw new \Exception("Unknown status code {$statusCode}!");
}
return $reflectionResponse->getConstant($constantName);
}
/**
* Get value of property by property name
* FIXME: Move to parent class Struct, when php will have late static binding
*
* @param $key
*/
public static function GetValue($key)
{
//property_exists
$ReflectionClassThis = new ReflectionClass(__CLASS__);
if ($ReflectionClassThis->hasConstant($key))
{
return $ReflectionClassThis->getConstant($key);
}
else
{
throw new Exception(sprintf(_("Called %s::GetValue('{$key}') for non-existent property {$key}"), __CLASS__));
}
}
public function instantiate($className, array $constructorArgs)
{
$class = new \ReflectionClass($this->qualifyClassName($className));
array_unshift($constructorArgs, $this->dataStore);
$newClass = $class->newInstanceArgs($constructorArgs);
if ($class->hasConstant("CUSTOM_DATA")) {
$newClass->customData;
}
if ($newClass instanceof \Stormpath\Resource\SamlProvider) {
$newClass = $this->convertSamlAttributeStatementMappingRules($newClass);
}
return $newClass;
}
/**
* @test
*/
public function testResourceConstants()
{
$reflection = new \ReflectionClass('Scalr\\Acl\\Acl');
$this->assertTrue($reflection->hasConstant('RESOURCE_FARMS'));
$this->assertEquals(0x100, Acl::RESOURCE_FARMS);
//All IDs of the resources must be unique
$uniq = array();
foreach ($reflection->getConstants() as $name => $value) {
if (strpos($name, 'RESOURCE_') === 0) {
$this->assertFalse(isset($uniq[$value]), sprintf('Not unique ID(0x%x) of the ACL resource has been found', $value));
$uniq[$value] = $name;
}
}
unset($uniq);
}
/**
* Create a new enum
* @param Object $value The enum value
*/
public function __construct($value = null)
{
$enum = new \ReflectionClass($this);
if ($value == null) {
if (!$enum->hasConstant(self::DEFAULT_NAME)) {
throw new \InvalidArgumentException("Cannot create enum as no value has been passed and no default is specified");
} else {
$value = $enum->getConstant(self::DEFAULT_NAME);
}
}
foreach ($enum->getConstants() as $name => $enumValue) {
if ($enumValue == $value) {
$this->value = $value;
return;
}
}
throw new \InvalidArgumentException("Unknown enum value " . $value);
}
/**
* Gets the table name from the 'TABLE' constant of the active record
* class if defined, otherwise use the class name as table name.
* @param TActiveRecord active record instance
* @return string table name for the given record class.
*/
protected function getRecordTableName(TActiveRecord $record)
{
$class = new ReflectionClass($record);
if ($class->hasConstant(self::TABLE_CONST)) {
$value = $class->getConstant(self::TABLE_CONST);
if (empty($value)) {
throw new TActiveRecordException('ar_invalid_tablename_property', get_class($record), self::TABLE_CONST);
}
return $value;
} elseif ($class->hasMethod(self::TABLE_METHOD)) {
$value = $record->{self::TABLE_METHOD}();
if (empty($value)) {
throw new TActiveRecordException('ar_invalid_tablename_method', get_class($record), self::TABLE_METHOD);
}
return $value;
} else {
return strtolower(get_class($record));
}
}
public function genericBlend($opacity = 1, $fill = 1, $mode = 'COPY', $options = array())
{
$class = new \ReflectionClass("\\Imagick");
if ($class->hasConstant('COMPOSITE_' . strtoupper($mode))) {
$baseImg = $this->base->getImage();
$overlayImg = $this->top->getImage();
$overlayImg->setImageOpacity($opacity);
if (!isset($options['botx'])) {
$options['botx'] = 0;
}
if (!isset($options['boty'])) {
$options['boty'] = 0;
}
$baseImg->compositeImage($overlayImg, constant('\\Imagick::COMPOSITE_' . strtoupper($mode)), $options['botx'], $options['boty']);
} else {
throw new \InvalidArgumentException('Blending mode ' . $mode . ' not available using Imagick');
return null;
}
return $baseImg;
}
public static function getType($fid)
{
$parts = explode(':', $fid);
if (strlen($fid) < 32 || !Numbers::between(count($parts), 4, 5)) {
return null;
}
if ($parts[0] != 'FID') {
return null;
}
$type = $subType = $parts[1];
if (count($parts) === 5) {
$subType = $parts[2];
}
$reflection = new \ReflectionClass('\\Fortifi\\FortifiApi\\Foundation\\Fids\\FidTypes');
$const = $type . '_' . $subType;
if ($reflection->hasConstant($const)) {
return $reflection->getConstant($const);
}
return null;
}
public function install()
{
$this->_hooks = array('displayCarrierList', 'actionValidateOrder', 'displayAdminOrder', 'displayBackOfficeHeader', 'displayFooter');
$installRes = parent::install();
if (!$installRes) {
return false;
}
$wys = Paczkomat::paczkomatUżytkownika("*****@*****.**");
$wysPaczk = Paczkomat::pobierzDanePaczkomatu($wys['glowny']);
$refl = new ReflectionClass($this);
foreach ($this->_konf as $name => $value) {
$defName = str_replace("KONFIG_", "DOM_", $name);
if ($refl->hasConstant($defName)) {
Configuration::updateValue(self::KONFIG_PREFIX . $value, $refl->getConstant($defName));
}
}
foreach (array(self::KONFIG_PACZKOMAT_WYSYLKOWY => base64_encode(serialize($wysPaczk['paczkomat']))) as $key => $value) {
Configuration::updateValue(self::KONFIG_PREFIX . $key, $value);
}
return $installRes;
}
/**
* {@inheritdoc}
*/
public function __construct(array $values)
{
$string = $values['value'];
// Handle classes.
if (strpos($string, '::') !== FALSE) {
list($class, $constant) = explode('::', $string);
try {
$reflection = new \ReflectionClass($class);
if ($reflection->hasConstant($constant)) {
$this->value = $reflection->getConstant($constant);
return;
}
} catch (\ReflectionException $e) {
}
}
// Handle procedural constants.
if (!$this->value && defined($string)) {
$this->value = constant($string);
return;
}
throw AnnotationException::semanticalErrorConstants($this->value);
}
public function testValidate()
{
$doctrine = new ReflectionClass('Doctrine');
if ($doctrine->hasConstant('VALIDATE_USER')) {
Doctrine_Manager::getInstance()->setAttribute(Doctrine_Core::ATTR_VALIDATE, Doctrine_Core::VALIDATE_USER);
} else {
//I only want my overridden Record->validate()-methods for validation
Doctrine_Manager::getInstance()->setAttribute(Doctrine_Core::ATTR_VALIDATE, Doctrine_Core::VALIDATE_ALL & ~Doctrine_Core::VALIDATE_LENGTHS & ~Doctrine_Core::VALIDATE_CONSTRAINTS & ~Doctrine_Core::VALIDATE_TYPES);
}
$user = Doctrine_Core::getTable('Ticket_1652_User')->findOneById(1);
$user->name = "test";
if ($user->isValid()) {
try {
$user->save();
} catch (Doctrine_Validator_Exception $dve) {
// ignore
}
}
$user = Doctrine_Core::getTable('Ticket_1652_User')->findOneById(1);
$this->assertNotEqual($user->name, 'test');
//reset validation to default for further testcases
Doctrine_Manager::getInstance()->setAttribute(Doctrine_Core::ATTR_VALIDATE, Doctrine_Core::VALIDATE_NONE);
}
protected function assertConstants(\ReflectionClass $reflection, array $constants)
{
foreach ($constants as $key => $value) {
$this->assertTrue($reflection->hasConstant($key));
$this->assertEquals($value, $reflection->getConstant($key));
}
$reflectionConstants = $reflection->getConstants();
$this->assertCount(count($constants), $reflectionConstants);
}
/**
*Checks if a class has a constant named $constant
*@param String $name class name
*@param String $constant constant to be checked
*@return boolean TRUE if the class has a constant named $constant
*@return boolean FALSE if the class doesn't has a constant named $constant
*@see self::parameterValidation for other return values
*/
public static function hasConstant($name, $constant)
{
$stdValidation = self::parameterValidation($name, $constant);
$rc = new \ReflectionClass($name);
return $rc->hasConstant($constant);
}
/**
* Get reflection for something
*
* @param string $thing The thing to get reflection for
*
* @return mixed ReflectionFoo instance
*/
protected function getReflection($thing)
{
switch (true) {
case is_object($thing):
return new ReflectionObject($thing);
case class_exists($thing, false):
return new ReflectionClass($thing);
case function_exists($thing):
return new ReflectionFunction($thing);
case strstr($thing, '::'):
list($class, $what) = explode('::', $thing);
$rc = new ReflectionClass($class);
switch (true) {
case substr($what, -2) == '()':
$what = substr($what, 0, strlen($what) - 2);
case $rc->hasMethod($what):
return $rc->getMethod($what);
case substr($what, 0, 1) == '$':
$what = substr($what, 1);
case $rc->hasProperty($what):
return $rc->getProperty($what);
case $rc->hasConstant($what):
return $rc->getConstant($what);
}
case is_string($thing):
return var_export($thing) . "\n";
}
}
/**
* Get ctype name
* extract constant CTYPE to ctype_id
*/
function _get_ctype()
{
if (!isset($this->_ctype)) {
if (loader::is_php53()) {
$this->_ctype = defined('static::CTYPE') ? static::CTYPE : false;
} else {
// php 5.2, no lsb
$class = get_class($this);
$reflector = new ReflectionClass($class);
$this->_ctype = $reflector->hasConstant('CTYPE') ? $reflector->getConstant('CTYPE') : false;
}
}
return $this->_ctype;
}
