Example #1
0
 /**
  * @param $request
  * @return array of validation messages
  */
 protected function validateRegisterRequest($request)
 {
     $messages = array();
     // email validations
     $emailNotEmpty = new \Zend\Validator\NotEmpty();
     $emailNotEmpty->setMessage('Email cannot be empty', \Zend\Validator\NotEmpty::IS_EMPTY);
     $emailValidEmail = new \Zend\Validator\EmailAddress();
     $emailValidEmail->setMessage('User email is not a valid email address. Use the basic format local-part@hostname', \Zend\Validator\EmailAddress::INVALID_FORMAT);
     $emailChain = new \Zend\Validator\ValidatorChain();
     $emailChain->attach($emailValidEmail);
     // is unique
     $user = $this->em()->getRepository('\\Application\\Entity\\User')->findBy(array('email' => $request['email']));
     if (count($user)) {
         $messages[] = "User with this email already exists";
     }
     // password validations
     $passwordNotEmpty = new \Zend\Validator\NotEmpty();
     $passwordNotEmpty->setMessage("User password cannot be empty", \Zend\Validator\NotEmpty::IS_EMPTY);
     $passwordStringLength = new \Zend\Validator\StringLength(['min' => 4, 'max' => 20]);
     $passwordStringLength->setMessage("User password is less than %min% characters long", \Zend\Validator\StringLength::TOO_SHORT);
     $passwordStringLength->setMessage("User password is more than %max% characters long", \Zend\Validator\StringLength::TOO_LONG);
     $passwordChain = new \Zend\Validator\ValidatorChain();
     $passwordChain->attach($passwordNotEmpty)->attach($passwordStringLength);
     if (!$passwordChain->isValid($request['password'])) {
         $messages = array_merge($messages, $passwordChain->getMessages());
     }
     if (!$emailChain->isValid($request['email'])) {
         $messages = array_merge($messages, $emailChain->getMessages());
     }
     return $messages;
 }
Example #2
0
 /**
  * Create input filter specification for integers
  *
  * @param string $name Element name
  * @return array
  */
 protected function _getIntegerFilter($name)
 {
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attachByName('Callback', array('callback' => array($this, 'validateType'), 'callbackOptions' => 'integer'), true);
     $validatorChain->attachByName('GreaterThan', array('min' => 0));
     return array('name' => $name, 'filters' => array(array('name' => 'Callback', 'options' => array('callback' => array($this, 'normalize'), 'callback_params' => 'integer'))), 'validators' => $validatorChain);
 }
Example #3
0
 /** {@inheritdoc} */
 public function init()
 {
     parent::init();
     $preferences = $this->get('Preferences');
     $inputFilter = new \Zend\InputFilter\InputFilter();
     $integerFilter = array('name' => 'Callback', 'options' => array('callback' => array($this, 'normalize'), 'callback_params' => 'integer'));
     $integerValidator = new \Zend\Validator\Callback(array('callback' => array($this, 'validateType'), 'callbackOptions' => 'integer'));
     $contactInterval = new \Zend\Form\Element\Text('contactInterval');
     $contactInterval->setLabel('Agent contact interval (in hours)')->setAttribute('size', 5);
     $preferences->add($contactInterval);
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attach($integerValidator, true)->attachByName('GreaterThan', array('min' => 0));
     $inputFilter->add(array('name' => 'contactInterval', 'filters' => array($integerFilter), 'validators' => $validatorChain));
     $inventoryInterval = new \Zend\Form\Element\Text('inventoryInterval');
     $inventoryInterval->setLabel('Inventory interval (in days, 0 = always, -1 = never)')->setAttribute('size', 5);
     $preferences->add($inventoryInterval);
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attach($integerValidator, true)->attachByName('GreaterThan', array('min' => -2));
     $inputFilter->add(array('name' => 'inventoryInterval', 'filters' => array($integerFilter), 'validators' => $validatorChain));
     $agentWhitelistFile = new \Zend\Form\Element\Text('agentWhitelistFile');
     $agentWhitelistFile->setLabel('File with allowed non-OCS agents (FusionInventory etc.)');
     $preferences->add($agentWhitelistFile);
     $inputFilter->add(array('name' => 'agentWhitelistFile', 'required' => false, 'validators' => array(array('name' => 'Library\\Validator\\FileReadable'))));
     $parentFilter = new \Zend\InputFilter\InputFilter();
     $parentFilter->add($inputFilter, 'Preferences');
     $this->setInputFilter($parentFilter);
 }
Example #4
0
 /** {@inheritdoc} */
 public function init()
 {
     parent::init();
     $what = new \Zend\Form\Element\Radio('What');
     $what->setValueOptions(array(\Model\Client\Client::MEMBERSHIP_AUTOMATIC => $this->_('Store search parameters. Group memberships will be updated automatically.'), \Model\Client\Client::MEMBERSHIP_ALWAYS => $this->_('Add current search results. Group memberships will be set only this time.'), \Model\Client\Client::MEMBERSHIP_NEVER => $this->_('Exclude search results from a group.')));
     $what->setValue(\Model\Client\Client::MEMBERSHIP_AUTOMATIC);
     $this->add($what);
     $where = new \Zend\Form\Element\Radio('Where');
     $where->setValueOptions(array('new' => $this->_('Store in new group'), 'existing' => $this->_('Store in existing group')));
     $where->setValue('new')->setAttribute('onchange', 'selectElements()');
     $this->add($where);
     $newGroup = new \Zend\Form\Element\Text('NewGroup');
     $newGroup->setLabel('Name');
     $this->add($newGroup);
     $description = new \Zend\Form\Element\Text('Description');
     $description->setLabel('Description');
     $this->add($description);
     $existingGroup = new \Library\Form\Element\SelectSimple('ExistingGroup');
     $existingGroup->setLabel('Group');
     $groups = array();
     foreach ($this->getOption('GroupManager')->getGroups(null, null, 'Name') as $group) {
         $groups[] = $group['Name'];
     }
     $existingGroup->setValueOptions($groups);
     $this->add($existingGroup);
     $submit = new \Library\Form\Element\Submit('Submit');
     $submit->setLabel('OK');
     $this->add($submit);
     $lengthValidator = new \Zend\Validator\Callback();
     $lengthValidator->setCallback(array($this, 'validateLength'))->setCallbackOptions(array(0, 255))->setTranslatorTextDomain('default')->setMessage('The input is more than 255 characters long');
     $requiredValidator = new \Zend\Validator\Callback();
     $requiredValidator->setCallback(array($this, 'validateLength'))->setCallbackOptions(array(1, 255))->setTranslatorTextDomain('default')->setMessage("Value is required and can't be empty");
     $existsValidator = new \Zend\Validator\Callback();
     $existsValidator->setCallback(array($this, 'validateGroupExists'))->setTranslatorTextDomain('default')->setMessage('The name already exists');
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attach($lengthValidator, true)->attach($requiredValidator, true)->attach($existsValidator, true);
     $inputFilter = new \Zend\InputFilter\InputFilter();
     $inputFilter->add(array('name' => 'NewGroup', 'continue_if_empty' => true, 'filters' => array(array('name' => 'StringTrim')), 'validators' => array($validatorChain)));
     $lengthValidator = new \Zend\Validator\Callback();
     $lengthValidator->setCallback(array($this, 'validateLength'))->setCallbackOptions(array(0, 255))->setTranslatorTextDomain('default')->setMessage('The input is more than 255 characters long');
     $inputFilter->add(array('name' => 'Description', 'required' => false, 'filters' => array(array('name' => 'StringTrim'), array('name' => 'Null', 'options' => array('type' => 'string'))), 'validators' => array($lengthValidator)));
     $this->setInputFilter($inputFilter);
 }
Example #5
0
 public function __construct($items = array(), $values = array())
 {
     /* run validator */
     foreach ($items as $key => $item) {
         /* apply default for unset value, and get value */
         if (isset($values[$key])) {
             $value = $values[$key];
             $items[$key]['value'] = $value;
         } else {
             if (isset($item['value'])) {
                 $value = $item['value'];
             } else {
                 $value = null;
                 $items[$key]['value'] = null;
             }
         }
         /* store values internally */
         $this->_values[$key] = $value;
         /* loop roles */
         foreach ($item as $role => $options) {
             /* exclude value */
             if ($role != 'value') {
                 /* prepare validation chain */
                 $chain = new \Zend\Validator\ValidatorChain();
                 /* attach role to chain */
                 switch ($role) {
                     case 'notempty':
                         $chain->attach(new \Zend\Validator\NotEmpty($options));
                         break;
                     case 'alnum':
                         $chain->attach(new \Zend\I18n\Validator\Alnum($options));
                         break;
                     case 'digits':
                         $chain->attach(new \Zend\Validator\Digits($options));
                         break;
                     case 'greaterthan':
                         $chain->attach(new \Zend\Validator\GreaterThan($options));
                         break;
                 }
                 /* validate, if invalid exit loop! */
                 if (!($this->_valid = $chain->isValid($value))) {
                     $this->_field = $key;
                     $this->_messages[$key] = $chain->getMessages();
                     break;
                 }
             }
             //value check
         }
         /* invalid? just exit loop */
         if (!$this->_valid) {
             break;
         }
     }
     /* store items internally */
     $this->items = $items;
 }
Example #6
0
 /** {@inheritdoc} */
 public function init()
 {
     parent::init();
     $preferences = $this->get('Preferences');
     $inputFilter = new \Zend\InputFilter\InputFilter();
     $trustedNetworksOnly = new \Zend\Form\Element\Checkbox('trustedNetworksOnly');
     $trustedNetworksOnly->setLabel('Limit agent connections to trusted networks');
     $preferences->add($trustedNetworksOnly);
     $inventoryFilter = new \Zend\Form\Element\Checkbox('inventoryFilter');
     $inventoryFilter->setLabel('Limit inventory frequency');
     $preferences->add($inventoryFilter);
     $limitInventoryInterval = new \Zend\Form\Element\Text('limitInventoryInterval');
     $limitInventoryInterval->setLabel('Seconds between inventory processing')->setAttribute('size', 5);
     $preferences->add($limitInventoryInterval);
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attachByName('Callback', array('callback' => array($this, 'validateType'), 'callbackOptions' => 'integer'), true);
     $validatorChain->attachByName('GreaterThan', array('min' => 0));
     $inputFilter->add(array('name' => 'limitInventoryInterval', 'required' => false, 'filters' => array(array('name' => 'Callback', 'options' => array('callback' => array($this, 'normalize'), 'callback_params' => 'integer'))), 'validators' => $validatorChain));
     $parentFilter = new \Zend\InputFilter\InputFilter();
     $parentFilter->add($inputFilter, 'Preferences');
     $this->setInputFilter($parentFilter);
 }
Example #7
0
 /** {@inheritdoc} */
 public function init()
 {
     parent::init();
     $preferences = $this->get('Preferences');
     $inputFilter = new \Zend\InputFilter\InputFilter();
     $integerFilter = array('name' => 'Callback', 'options' => array('callback' => array($this, 'normalize'), 'callback_params' => 'integer'));
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attachByName('Callback', array('callback' => array($this, 'validateType'), 'callbackOptions' => 'integer'), true);
     $validatorChain->attachByName('GreaterThan', array('min' => 0));
     $groupCacheExpirationInterval = new \Zend\Form\Element\Text('groupCacheExpirationInterval');
     $groupCacheExpirationInterval->setLabel('Minimum seconds between group cache rebuilds')->setAttribute('size', 5);
     $preferences->add($groupCacheExpirationInterval);
     $inputFilter->add(array('name' => 'groupCacheExpirationInterval', 'filters' => array($integerFilter), 'validators' => $validatorChain));
     $groupCacheExpirationFuzz = new \Zend\Form\Element\Text('groupCacheExpirationFuzz');
     $groupCacheExpirationFuzz->setLabel('Maximum seconds added to above value')->setAttribute('size', 5);
     $preferences->add($groupCacheExpirationFuzz);
     $inputFilter->add(array('name' => 'groupCacheExpirationFuzz', 'filters' => array($integerFilter), 'validators' => $validatorChain));
     $setGroupPackageStatus = new \Zend\Form\Element\Checkbox('setGroupPackageStatus');
     $setGroupPackageStatus->setLabel('Set package status on clients for group-assigned packages');
     $preferences->add($setGroupPackageStatus);
     $parentFilter = new \Zend\InputFilter\InputFilter();
     $parentFilter->add($inputFilter, 'Preferences');
     $this->setInputFilter($parentFilter);
 }
Example #8
0
    return $factory->createInstance(array('name' => 'credential', 'validator' => $validator, 'required' => true));
}, 'Acl\\Import\\User\\Validator' => function ($sm) {
    $validator = new \Acl\Model\Import\ImportValidator();
    $validator->addColumnDefinition($sm->get('Acl\\Import\\ColumnDefinition\\UniqueIdentity'))->addColumnDefinition($sm->get('Acl\\Import\\ColumnDefinition\\Credential'));
    return $validator;
}, 'Acl\\Import\\User' => function ($sm) {
    $manager = $sm->get('Acl\\Entity\\Manager');
    $factory = $sm->get('Acl\\Factory\\User');
    $wrapper = $sm->get('Acl\\Wrapper\\User');
    $adapter = $sm->get('Acl\\Import\\Adapter\\CsvFile');
    $validator = $sm->get('Acl\\Import\\User\\Validator');
    $import = new \Acl\Model\Import\EntityImport();
    $import->setManager($manager)->setFactory($factory)->setWrapper($wrapper)->setAdapter($adapter)->setValidator($validator);
    return $import;
}, 'Acl\\Import\\ColumDefinition\\AttributeName\\ValidatorChain' => function ($sm) {
    $chain = new \Zend\Validator\ValidatorChain();
    $chain->attachByName('NotEmpty', array('messages' => array(\Zend\Validator\NotEmpty::IS_EMPTY => 'Value for [name] column is required and cannot be empty')), true);
    return $chain;
}, 'Acl\\Import\\ColumnDefinition\\AttributeName' => function ($sm) {
    $validator = $sm->get('Acl\\Import\\ColumDefinition\\AttributeName\\ValidatorChain');
    $factory = $sm->get('Acl\\Factory\\ColumnDefinition');
    return $factory->createInstance(array('name' => 'name', 'validator' => $validator, 'required' => true));
}, 'Acl\\Import\\Attribute\\Validator' => function ($sm) {
    $validator = new \Acl\Model\Import\ImportValidator();
    $validator->addColumnDefinition($sm->get('Acl\\Import\\ColumnDefinition\\Identity'))->addColumnDefinition($sm->get('Acl\\Import\\ColumnDefinition\\AttributeName'));
    return $validator;
}, 'Acl\\Import\\Attribute' => function ($sm) {
    $manager = $sm->get('Acl\\Entity\\Manager');
    $factory = $sm->get('Acl\\Factory\\Attribute');
    $wrapper = $sm->get('Acl\\Wrapper\\Attribute');
    $adapter = $sm->get('Acl\\Import\\Adapter\\CsvFile');
 $validater = $app->getServiceManager()->get('validationChainerServiceForZendChainer');
 $validatorChainUrl = new Zend\Validator\ValidatorChain();
 $validater->offsetSet(array_search($_GET['url'], $_GET), new \Utill\Validation\Chain\ZendValidationChainer($app, $_GET['url'], $validatorChainUrl->attach(new Zend\Validator\StringLength(array('min' => 6, 'max' => 50)))));
 $validatorChainLanguageCode = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('language_code', new \Utill\Validation\Chain\ZendValidationChainer($app, $vLanguageCode, $validatorChainLanguageCode->attach(new Zend\Validator\StringLength(array('min' => 2, 'max' => 2)))->attach(new Zend\I18n\Validator\Alpha())));
 $validatorChainId = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('id', new \Utill\Validation\Chain\ZendValidationChainer($app, $vID, $validatorChainId->attach(new Zend\Validator\StringLength(array('min' => 1)))->attach(new Zend\Validator\Digits())));
 $validatorChainOperationTypeId = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('operation_type_id', new \Utill\Validation\Chain\ZendValidationChainer($app, $vOperationTypeId, $validatorChainOperationTypeId->attach(new Zend\Validator\StringLength(array('min' => 1)))->attach(new Zend\Validator\Digits())));
 $validatorChainActive = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('active', new \Utill\Validation\Chain\ZendValidationChainer($app, $vActive, $validatorChainActive->attach(new Zend\Validator\StringLength(array('min' => 1, 'max' => 1)))->attach(new Zend\Validator\Digits())));
 $validatorChainProfilePublic = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('profile_public', new \Utill\Validation\Chain\ZendValidationChainer($app, $vProfilePublic, $validatorChainProfilePublic->attach(new Zend\Validator\StringLength(array('min' => 1, 'max' => 1)))->attach(new Zend\Validator\Digits())));
 $validatorChainConsAllowId = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('cons_allow_id', new \Utill\Validation\Chain\ZendValidationChainer($app, $vConsAllowId, $validatorChainConsAllowId->attach(new Zend\Validator\StringLength(array('min' => 1, 'max' => 1)))->attach(new Zend\Validator\Digits())));
 $validatorChainActParentId = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('act_parent_id', new \Utill\Validation\Chain\ZendValidationChainer($app, $vActParentId, $validatorChainActParentId->attach(new Zend\Validator\StringLength(array('min' => 1, 'max' => 1)))->attach(new Zend\Validator\Digits())));
 $validater->validate();
 $messager = $app->getServiceManager()->get('validatorMessager');
 print_r($messager->getValidationMessage());
 $fID = $vID;
 $fOperationTypeId = $vOperationTypeId;
 $fActive = $vActive;
 $fActParentId = $vActParentId;
 $fLanguageCode = $vLanguageCode;
 $fProfilePublic = $vProfilePublic;
 $fCommunicationsTypeId = $vCommunicationsTypeId;
 $fCommunicationsNo = $vCommunicationsNo;
 $fDescription = $vDescription;
 $fDescriptionEng = $vDescriptionEng;
 $fConsAllowId = $vConsAllowId;
 ///////////////////**** validator
 /**
  * validat chain test
  * @author Mustafa Zeynel Dağlı
  * @since 15/01/2016
  */
 $vName = $_GET['name'];
 $vUrl = $_GET['url'];
 $vParent = $_GET['parent'];
 $vIconClass = $_GET['icon_class'];
 $vDescription = $_GET['description'];
 $vUserId = $_GET['user_ID'];
 $validater = $app->getServiceManager()->get('validationChainerServiceForZendChainer');
 $validatorChainUrl = new Zend\Validator\ValidatorChain();
 $validater->offsetSet(array_search($_GET['url'], $_GET), new \Utill\Validation\Chain\ZendValidationChainer($app, $_GET['url'], $validatorChainUrl->attach(new Zend\Validator\StringLength(array('min' => 6, 'max' => 50)))));
 $validatorChainName = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('name', new \Utill\Validation\Chain\ZendValidationChainer($app, $vName, $validatorChainName->attach(new Zend\Validator\StringLength(array('min' => 3, 'max' => 10)))->attach(new Zend\I18n\Validator\Alnum())));
 $validater->offsetSet('parent', new \Utill\Validation\Chain\ZendValidationChainer($app, $vParent, $validatorChainName->attach(new Zend\Validator\StringLength(array('min' => 3, 'max' => 10)))->attach(new Zend\I18n\Validator\Alnum())));
 $validater->validate();
 $messager = $app->getServiceManager()->get('validatorMessager');
 print_r($messager->getValidationMessage());
 /***validator ***/
 $stripper = $app->getServiceManager()->get('filterChainerCustom');
 //print_r('---'.array_search($_GET['url'], $_GET).'???');
 $stripper->offsetSet(array_search($_GET['url'], $_GET), new \Utill\Strip\Chain\StripChainer($app, $_GET['url'], array(\Services\Filter\FilterServiceNames::FILTER_SQL_RESERVEDWORDS, \Services\Filter\FilterServiceNames::FILTER_HTML_TAGS_CUSTOM_ADVANCED, \Services\Filter\FilterServiceNames::FILTER_JAVASCRIPT_FUNCTIONS, \Services\Filter\FilterServiceNames::FILTER_HEXADECIMAL_ADVANCED, \Services\Filter\FilterServiceNames::FILTER_ONLY_ALPHABETIC_ALLOWED)));
 $stripper->offsetSet('name', new \Utill\Strip\Chain\StripChainer($app, $_GET['name'], array(\Services\Filter\FilterServiceNames::FILTER_DEFAULT, \Services\Filter\FilterServiceNames::FILTER_HEXADECIMAL_ADVANCED, \Services\Filter\FilterServiceNames::FILTER_HTML_TAGS_CUSTOM_ADVANCED, \Services\Filter\FilterServiceNames::FILTER_JAVASCRIPT_FUNCTIONS, \Services\Filter\FilterServiceNames::FILTER_LOWER_CASE, \Services\Filter\FilterServiceNames::FILTER_SQL_RESERVEDWORDS)));
 /*$stripper->offsetSet(array_search($_GET['icon_class'], $_GET), new \Utill\Strip\Chain\StripChainer($app, $_GET['icon_class'], array(
                                                                                             \Services\Filter\FilterServiceNames::FILTER_DEFAULT,  
                                                                                             \Services\Filter\FilterServiceNames::FILTER_HEXADECIMAL_ADVANCED,  
                                                                                             \Services\Filter\FilterServiceNames::FILTER_HTML_TAGS_CUSTOM_ADVANCED,
                                                                                             \Services\Filter\FilterServiceNames::FILTER_JAVASCRIPT_FUNCTIONS ,
Example #11
0
 public function testCanCreateFormFromConcreteClassAndSpecifyCustomValidatorByName()
 {
     $validatorManager = new \Zend\Validator\ValidatorPluginManager();
     $validatorManager->setInvokableClass('baz', 'ZendTest\\Validator\\TestAsset\\ConcreteValidator');
     $defaultValidatorChain = new \Zend\Validator\ValidatorChain();
     $defaultValidatorChain->setPluginManager($validatorManager);
     $inputFilterFactory = new \Zend\InputFilter\Factory();
     $inputFilterFactory->setDefaultValidatorChain($defaultValidatorChain);
     $factory = new FormFactory();
     $factory->setInputFilterFactory($inputFilterFactory);
     $form = $factory->createForm(array('name' => 'foo', 'factory' => $factory, 'input_filter' => array('bar' => array('name' => 'bar', 'required' => true, 'validators' => array(array('name' => 'baz'))))));
     $this->assertInstanceOf('Zend\\Form\\FormInterface', $form);
     $inputFilter = $form->getInputFilter();
     $this->assertInstanceOf('Zend\\InputFilter\\InputFilterInterface', $inputFilter);
     $input = $inputFilter->get('bar');
     $this->assertInstanceOf('Zend\\InputFilter\\Input', $input);
     $validatorChain = $input->getValidatorChain();
     $this->assertInstanceOf('Zend\\Validator\\ValidatorChain', $validatorChain);
     $validatorArray = $validatorChain->getValidators();
     $found = false;
     foreach ($validatorArray as $validator) {
         $validatorInstance = $validator['instance'];
         $this->assertInstanceOf('Zend\\Validator\\ValidatorInterface', $validatorInstance);
         if ($validatorInstance instanceof \ZendTest\Validator\TestAsset\ConcreteValidator) {
             $found = true;
             break;
         }
     }
     $this->assertTrue($found);
 }
Example #12
0
 public function index19Action()
 {
     echo "<h3 style='color:red;font-weight:bold'>" . __METHOD__ . "</h3>";
     //username
     //khong duoc rong
     //chieu dai tu 5 -8
     //bat dau bang Z ket thuc bang 1 số
     $validator = new \Zend\Validator\ValidatorChain();
     if ($this->getRequest()->isPost()) {
         $username = $this->params()->fromPost("username");
         $validator->attach(new \Zend\Validator\NotEmpty(), true)->attach(new \Zend\Validator\StringLength(5, 8), true)->attach(new \Zend\Validator\Regex("#^z[a-zA-Z0-9_-]{3,6}[0-9]{1}\$#imsU"));
         if (!$validator->isValid($username)) {
             $message = $validator->getMessages();
             echo "<pre style='font-weight:bold'>";
             print_r($message);
             echo "</pre>";
         } else {
             echo "ok";
         }
     }
 }
Example #13
0
 public function saveUrl($data, $pageRes)
 {
     $jsonModel = new JsonModel();
     $em = $this->getEntityManager();
     $form = new PageUrlForm();
     $form->bind($pageRes);
     $validateChain = new \Zend\Validator\ValidatorChain();
     $validateChain->attach(new \Zend\Validator\Uri());
     $filters = $form->getInputFilter();
     $filters->get('url')->setRequired(true)->setValidatorChain($validateChain);
     $form->setInputFilter($filters);
     $form->setData($data);
     if ($form->isValid()) {
         $em->persist($pageRes);
         $em->flush();
         $jsonModel->setVariable('success', true);
     } else {
         $jsonModel->setVariable('success', false);
         $jsonModel->setVariable('message', $form->getMessages());
     }
     return $jsonModel;
 }
Example #14
0
 /**
  * Get input filter specification for an integer field
  *
  * @param string $name Field name
  * @param integer $min Allowed minimum value
  * @return array
  */
 protected function _getIntegerFilter($name, $min)
 {
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attachByName('Callback', array('callback' => array($this, 'validateInteger')), true);
     // Callback validators do not support message variables. For
     // translatable messages with a parameter, do translation and
     // substitution here and disable further translation.
     $message = "The input is not greater or equal than '%min%'";
     // Prevent extraction by xgettext
     $minValueValidator = new \Zend\Validator\Callback();
     $minValueValidator->setCallback(array($this, 'validateMinValue'))->setCallbackOptions($min)->setMessage(str_replace('%min%', $min, $minValueValidator->getTranslator()->translate($message)))->setTranslatorEnabled(false);
     $validatorChain->attach($minValueValidator);
     return array('name' => $name, 'required' => false, 'filters' => array(array('name' => 'Callback', 'options' => array('callback' => array($this, 'filterInteger')))), 'validators' => $validatorChain);
 }
Example #15
0
 /**
  * Call
  */
 public function call()
 {
     //print_r('MiddlewareTest middleware call method------');
     //print_r($this->next);
     //Read flash messaging from previous request if available
     //$this->loadMessages();
     //Prepare flash messaging for current request
     //$env = $this->app->environment();
     //$env['slim.flash'] = $this;
     // Create a validator chain and add validators to it
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attach(new \Zend\Validator\StringLength(array('min' => 6, 'max' => 12)))->attach(new \Zend\I18n\Validator\Alnum());
     // Validate the username
     if ($validatorChain->isValid("testteeewwwwwwwwwwwww__")) {
         // username passed validation
     } else {
         // username failed validation; print reasons
         /* foreach ($validatorChain->getMessages() as $message) {
                echo "$message\n";
            }*/
         //$this->app->redirect('/error');
         //$this->app->error();
         //$this->app->halt(500, "info status test!!!!");
         /*$this->app->contentType('application/json');
           $this->app->halt(500, '{"error":"Something went wrong"}');
           $this->app->stop();*/
         //exit();
         //$this->app->run();
         /*$response = $this->app->response();
         
                     //Generate Response headers
                     $response->header('Content-Type', "application/json");
                     $response->status(DEFAULT_RESPONSE_CODE);                  
                     $response->header('Content-Length', '500');
         
                     $responseBody = array('message'=> $message);
                     $response->body(json_encode($responseBody));
         
         
                     $response->send();*/
         //ob_clean();
         $publicHash = '3441df0babc2a2dda551d7cd39fb235bc4e09cd1e4556bf261bb49188f548348';
         $privateHash = 'e249c439ed7697df2a4b045d97d4b9b7e1854c3ff8dd668c779013653913572e';
         $content = json_encode(array('test' => 'content'));
         //$this->app->setPublicHash('3441df0babc2a2dda551d7cd39fb235bc4e09cd1e4556bf261bb49188f548348');
         //
         //print_r("------public hash---------".$this->app->getPublicHash()."------public hash---------");
         /*$hash = hash_hmac('sha256', $content, $privateHash);
         
                     $headers = array(
                         'X-Public: '.$publicHash,
                         'X-Hash: '.$hash
                     );
                     //ob_flush();
                     
                     
                     $ch = curl_init('http://localhost/slim_redirect_test/index.php/redirected_path');
                     curl_setopt($ch,CURLOPT_HTTPHEADER,$headers);
                     curl_setopt($ch,CURLOPT_RETURNTRANSFER,true);
                     curl_setopt($ch,CURLOPT_POSTFIELDS,$content);
         
                     $result = curl_exec($ch);
                     curl_close($ch);*/
         //ob_end_flush();
         /*ob_end_clean();
           $newURL = 'http://localhost/slim_redirect_test/index.php/redirected_path';
           header("Location: {$newURL}");*/
     }
     $validator = new \Zend\Validator\Barcode('EAN13');
     $floatValidator = new \Zend\I18n\Validator\IsFloat();
     if ($floatValidator->isValid(5.3)) {
         //print_r ("--float test edildi onaylandı---");
         $intValidator = new \Zend\I18n\Validator\IsInt();
     }
     $intValidator->setMessage("test validation");
     if ($intValidator->isValid(5)) {
         //print_r ("--int test edildi onaylandı---");
         $validator = new \Zend\Validator\StringLength();
     }
     $validator->setMax(6);
     $validator->isValid("Test");
     // returns true
     $validator->isValid("Testing");
     // returns false
     /*print_r($validator->isValid("Test"));
       print_r("fffffffffffffffffffff----    ");
       print_r($validator->isValid("Testing"));*/
     if (!$validator->isValid("Testing")) {
         //print_r("---is not valid----");
         $logger = new \Zend\Log\Logger();
     }
     $writer = new \Zend\Log\Writer\Stream('php://output');
     /*$logger->addWriter($writer);
       $logger->log(\Zend\Log\Logger::INFO, 'Informational message');
       $this->app->log->debug("test loggg");*/
     $this->next->call();
     //$this->save();
 }
Example #16
0
<?php

require_once './autoloader.php';
$translator = Zend\I18n\Translator\Translator::factory(array('locale' => 'zh', 'translation_file_patterns' => array('zf' => array('type' => 'PhpArray', 'base_dir' => EVA_LIB_PATH . '/Zend/resources/languages/', 'pattern' => '%s/Zend_Validate.php'))));
Zend\Validator\AbstractValidator::setDefaultTranslator($translator);
$validatorChain = new Zend\Validator\ValidatorChain();
$validatorChain->addValidator(new Zend\Validator\StringLength(array('min' => 6, 'max' => 12)))->addValidator(new Zend\Validator\NotEmpty());
$username = '';
// Validate the username
if ($validatorChain->isValid($username)) {
    // username passed validation
} else {
    // username failed validation; print reasons
    foreach ($validatorChain->getMessages() as $message) {
        p($message);
    }
}
Example #17
0
 public function isValid($tmp_name)
 {
     $chain = new \Zend\Validator\ValidatorChain();
     $chain->addValidator(new \Zend\Validator\File\FilesSize(array('min' => 100, 'max' => '2MB')));
     $chain->addValidator(new \Zend\Validator\File\Extension(array('jpg', 'jpeg', 'png', 'gif')));
     $chain->addValidator(new \Zend\Validator\File\MimeType(array('image/jpeg', 'image/png', 'image/jpg', 'image/gif')));
     if ($chain->isValid($tmp_name)) {
         return true;
     }
     $this->_errors = $chain->getMessages();
     return false;
 }
 $vAddress2 = $_GET['address2'];
 $vPostalCode = $_GET['postal_code'];
 $vCountryId = $_GET['country_id'];
 $vCityId = $_GET['city_id'];
 $vBoroughId = $_GET['borough_id'];
 $vCityName = $_GET['city_name'];
 $vDescription = $_GET['description'];
 $vDescriptionEng = $_GET['description_eng'];
 $validater = $app->getServiceManager()->get('validationChainerServiceForZendChainer');
 $validatorChainUrl = new Zend\Validator\ValidatorChain();
 $validater->offsetSet(array_search($_GET['url'], $_GET), new \Utill\Validation\Chain\ZendValidationChainer($app, $_GET['url'], $validatorChainUrl->attach(new Zend\Validator\StringLength(array('min' => 6, 'max' => 50)))));
 $validatorChainLanguageCode = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('language_code', new \Utill\Validation\Chain\ZendValidationChainer($app, $vLanguageCode, $validatorChainLanguageCode->attach(new Zend\Validator\StringLength(array('min' => 2, 'max' => 2)))->attach(new Zend\I18n\Validator\Alpha())));
 $validatorChainId = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('id', new \Utill\Validation\Chain\ZendValidationChainer($app, $vID, $validatorChainId->attach(new Zend\Validator\StringLength(array('min' => 1)))->attach(new Zend\Validator\Digits())));
 $validatorChainProfilePublic = new Zend\Validator\ValidatorChain();
 $validater->offsetSet('profile_public', new \Utill\Validation\Chain\ZendValidationChainer($app, $vProfilePublic, $validatorChainProfilePublic->attach(new Zend\Validator\StringLength(array('min' => 1, 'max' => 1)))->attach(new Zend\Validator\Digits())));
 $validater->validate();
 $messager = $app->getServiceManager()->get('validatorMessager');
 print_r($messager->getValidationMessage());
 $fID = $vID;
 $fLanguageCode = $vLanguageCode;
 $fProfilePublic = $vProfilePublic;
 $fAddressTypeId = $vAddressTypeId;
 $fAddress1 = $vAddress1;
 $fAddress2 = $vAddress2;
 $fPostalCode = $vPostalCode;
 $fCountryId = $vCountryId;
 $fCityId = $vCityId;
 $fBoroughId = $vBoroughId;
 $fCityName = $vCityName;
 /** this function called by indexAction to reduce complexity of function */
 protected function authenticate($form = null, $viewModel = null)
 {
     $request = $this->getRequest();
     if ($request->isPost()) {
         $authManager = $this->getServiceLocator()->get('authenticationManagerDefault');
         // Create a validator chain and add validators to it
         $validatorChain = new \Zend\Validator\ValidatorChain();
         $validatorChain->attach(new \Zend\Validator\StringLength(array('min' => 6, 'max' => 100)))->attach(new \Zend\Validator\NotEmpty())->attach(new \Zend\Validator\EmailAddress());
         // Validate the email
         if ($validatorChain->isValid($_POST['eposta'])) {
             $authManager->getAdapter()->setIdentity($_POST['eposta'])->setCredential($_POST['sifre']);
             $result = $authManager->authenticate();
             //print_r($result);
             if ($result->getCode() == 1) {
                 /**
                  * creating a public key for every login operation
                  * @author Mustafa Zeynel Dağlı
                  * @since 04/01/2016
                  */
                 $publicKey = $this->getServiceLocator()->get('servicePublicKeyGenerator');
                 //print_r($publicKey);
                 /**
                  * when public key not created service returns true,
                  * if public key true we should logout
                  * @author Mustafa Zeynel Dağlı
                  * @since 27/01/2016
                  */
                 if ($publicKey != true) {
                     $event = $this->getEvent();
                     $authManager->getStorage()->clear();
                     $response = $this->getResponse();
                     $url = $event->getRouter()->assemble(array('action' => 'index'), array('name' => 'sanalfabrika'));
                     $response->setHeaders($response->getHeaders()->addHeaderLine('Location', $url));
                     $response->setStatusCode(302);
                     $response->sendHeaders();
                     $event->stopPropagation();
                     exit;
                 }
                 $this->getServiceLocator()->setService('identity', $result->getIdentity());
                 //print_r($this->getServiceLocator()->get('identity'));
                 $userID = null;
                 $userIDService = $this->getServiceLocator()->get('serviceUserIDFinder');
                 if (is_integer($userIDService)) {
                     $userID = $userIDService;
                 }
                 $userID = $userIDService;
                 $authManager->getStorage()->write(array('id' => $userID, 'username' => $result->getIdentity(), 'ip_address' => $this->getRequest()->getServer('REMOTE_ADDR'), 'user_agent' => $request->getServer('HTTP_USER_AGENT'), 'pk' => $publicKey));
                 /**
                  * user role service will be tested
                  * @author Mustafa Zeynel Dağlı
                  * @since 28/01/2016
                  */
                 $this->getServiceLocator()->get('serviceRoleSessionWriter');
                 //print_r('---serviceRoleSessionWriter çağırıldı');
                 /**
                  * the public key cretaed is being inserted to database
                  * @author Mustafa Zeynel Dağlı
                  * @since 04/01/2016
                  */
                 $this->getServiceLocator()->get('servicePublicKeySaver');
                 //print_r('---servicePublicKeySaver çağırıldı');
                 //exit();
                 /**
                  * user login logged by rabbitMQ messaging
                  * @author Mustafa Zeynel Dağlı
                  * @since 17/03/2016
                  */
                 $this->getServiceLocator()->get('serviceLoginLogRabbitMQ');
                 /**
                  * redirecting after success
                  */
                 $this->getServiceLocator()->get('serviceAuthenticatedRedirectManager');
             }
         } else {
             $authManager->getStorage()->clear();
             $viewModel->notValidated = true;
         }
     }
 }
Example #20
0
 /**
  * Get input filter specification for an integer field
  *
  * @param string $name Field name
  * @param integer $min Allowed minimum value
  * @return array
  */
 protected function _getIntegerFilter($name, $min)
 {
     $validatorChain = new \Zend\Validator\ValidatorChain();
     $validatorChain->attachByName('Callback', array('callback' => array($this, 'validateInteger')), true);
     $minValueValidator = new \Zend\Validator\Callback();
     $minValueValidator->setCallback(array($this, 'validateMinValue'))->setCallbackOptions($min)->setMessage("The input is not greater or equal than '{$min}'");
     $validatorChain->attach($minValueValidator);
     return array('name' => $name, 'required' => false, 'filters' => array(array('name' => 'Callback', 'options' => array('callback' => array($this, 'filterInteger')))), 'validators' => $validatorChain);
 }