/**
  * {@inheritdoc}
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  * @SuppressWarnings(PHPMD.NPathComplexity)
  */
 public function validateValue($value)
 {
     $errors = [];
     $attribute = $this->getAttribute();
     $label = __($attribute->getStoreLabel());
     if ($value === false) {
         // try to load original value and validate it
         $value = $this->_value;
     }
     if ($attribute->isRequired() && empty($value) && $value !== '0') {
         $errors[] = __('"%1" is a required value.', $label);
     }
     if (!$errors && !$attribute->isRequired() && empty($value)) {
         return true;
     }
     // validate length
     $length = $this->_string->strlen(trim($value));
     $validateRules = $attribute->getValidationRules();
     $minTextLength = ArrayObjectSearch::getArrayElementByName($validateRules, 'min_text_length');
     if ($minTextLength !== null && $length < $minTextLength) {
         $errors[] = __('"%1" length must be equal or greater than %2 characters.', $label, $minTextLength);
     }
     $maxTextLength = ArrayObjectSearch::getArrayElementByName($validateRules, 'max_text_length');
     if ($maxTextLength !== null && $length > $maxTextLength) {
         $errors[] = __('"%1" length must be equal or less than %2 characters.', $label, $maxTextLength);
     }
     $result = $this->_validateInputRule($value);
     if ($result !== true) {
         $errors = array_merge($errors, $result);
     }
     if (count($errors) == 0) {
         return true;
     }
     return $errors;
 }

 /**
  * Validate data
  * Return true or array of errors
  *
  * @param array|string $value
  * @return bool|array
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  * @SuppressWarnings(PHPMD.NPathComplexity)
  */
 public function validateValue($value)
 {
     $errors = [];
     $attribute = $this->getAttribute();
     $label = __($attribute->getStoreLabel());
     if ($value === false) {
         // try to load original value and validate it
         $value = $this->getEntity()->getDataUsingMethod($attribute->getAttributeCode());
     }
     if ($attribute->getIsRequired() && empty($value) && $value !== '0') {
         $errors[] = __('"%1" is a required value.', $label);
     }
     if (!$errors && !$attribute->getIsRequired() && empty($value)) {
         return true;
     }
     // validate length
     $length = $this->_string->strlen(trim($value));
     $validateRules = $attribute->getValidateRules();
     if (!empty($validateRules['min_text_length']) && $length < $validateRules['min_text_length']) {
         $v = $validateRules['min_text_length'];
         $errors[] = __('"%1" length must be equal or greater than %2 characters.', $label, $v);
     }
     if (!empty($validateRules['max_text_length']) && $length > $validateRules['max_text_length']) {
         $v = $validateRules['max_text_length'];
         $errors[] = __('"%1" length must be equal or less than %2 characters.', $label, $v);
     }
     $result = $this->_validateInputRule($value);
     if ($result !== true) {
         $errors = array_merge($errors, $result);
     }
     if (count($errors) == 0) {
         return true;
     }
     return $errors;
 }

 /**
  * Draw item line
  *
  * @return void
  */
 public function draw()
 {
     $item = $this->getItem();
     $pdf = $this->getPdf();
     $page = $this->getPage();
     $lines = [];
     // draw Product name
     $lines[0] = [['text' => $this->string->split($item->getName(), 60, true, true), 'feed' => 100]];
     // draw QTY
     $lines[0][] = ['text' => $item->getQty() * 1, 'feed' => 35];
     // draw SKU
     $lines[0][] = ['text' => $this->string->split($this->getSku($item), 25), 'feed' => 565, 'align' => 'right'];
     // Custom options
     $options = $this->getItemOptions();
     if ($options) {
         foreach ($options as $option) {
             // draw options label
             $lines[][] = ['text' => $this->string->split($this->filterManager->stripTags($option['label']), 70, true, true), 'font' => 'italic', 'feed' => 110];
             // draw options value
             if ($option['value']) {
                 $printValue = isset($option['print_value']) ? $option['print_value'] : $this->filterManager->stripTags($option['value']);
                 $values = explode(', ', $printValue);
                 foreach ($values as $value) {
                     $lines[][] = ['text' => $this->string->split($value, 50, true, true), 'feed' => 115];
                 }
             }
         }
     }
     $lineBlock = ['lines' => $lines, 'height' => 20];
     $page = $pdf->drawLineBlocks($page, [$lineBlock], ['table_header' => true]);
     $this->setPage($page);
 }

 /**
  * Draw item line
  *
  * @return void
  */
 public function draw()
 {
     $order = $this->getOrder();
     $item = $this->getItem();
     $pdf = $this->getPdf();
     $page = $this->getPage();
     $lines = [];
     // draw Product name
     $lines[0] = [['text' => $this->string->split($item->getName(), 35, true, true), 'feed' => 35]];
     // draw SKU
     $lines[0][] = ['text' => $this->string->split($this->getSku($item), 17), 'feed' => 290, 'align' => 'right'];
     // draw QTY
     $lines[0][] = ['text' => $item->getQty() * 1, 'feed' => 435, 'align' => 'right'];
     // draw item Prices
     $i = 0;
     $prices = $this->getItemPricesForDisplay();
     $feedPrice = 395;
     $feedSubtotal = $feedPrice + 170;
     foreach ($prices as $priceData) {
         if (isset($priceData['label'])) {
             // draw Price label
             $lines[$i][] = ['text' => $priceData['label'], 'feed' => $feedPrice, 'align' => 'right'];
             // draw Subtotal label
             $lines[$i][] = ['text' => $priceData['label'], 'feed' => $feedSubtotal, 'align' => 'right'];
             $i++;
         }
         // draw Price
         $lines[$i][] = ['text' => $priceData['price'], 'feed' => $feedPrice, 'font' => 'bold', 'align' => 'right'];
         // draw Subtotal
         $lines[$i][] = ['text' => $priceData['subtotal'], 'feed' => $feedSubtotal, 'font' => 'bold', 'align' => 'right'];
         $i++;
     }
     // draw Tax
     $lines[0][] = ['text' => $order->formatPriceTxt($item->getTaxAmount()), 'feed' => 495, 'font' => 'bold', 'align' => 'right'];
     // custom options
     $options = $this->getItemOptions();
     if ($options) {
         foreach ($options as $option) {
             // draw options label
             $lines[][] = ['text' => $this->string->split($this->filterManager->stripTags($option['label']), 40, true, true), 'font' => 'italic', 'feed' => 35];
             if ($option['value']) {
                 if (isset($option['print_value'])) {
                     $printValue = $option['print_value'];
                 } else {
                     $printValue = $this->filterManager->stripTags($option['value']);
                 }
                 $values = explode(', ', $printValue);
                 foreach ($values as $value) {
                     $lines[][] = ['text' => $this->string->split($value, 30, true, true), 'feed' => 40];
                 }
             }
         }
     }
     $lineBlock = ['lines' => $lines, 'height' => 20];
     $page = $pdf->drawLineBlocks($page, [$lineBlock], ['table_header' => true]);
     $this->setPage($page);
 }

 /**
  * Renders grid column
  *
  * @param \Magento\Framework\DataObject $row
  * @return string
  */
 public function render(\Magento\Framework\DataObject $row)
 {
     $line = parent::_getValue($row);
     $wrappedLine = '';
     $lineLength = $this->getColumn()->getData('lineLength') ? $this->getColumn()->getData('lineLength') : $this->_defaultMaxLineLength;
     for ($i = 0, $n = floor($this->string->strlen($line) / $lineLength); $i <= $n; $i++) {
         $wrappedLine .= $this->string->substr($line, $lineLength * $i, $lineLength) . "<br />";
     }
     return $wrappedLine;
 }

 /**
  * Renders a column
  *
  * @param   \Magento\Framework\DataObject $row
  * @return  string
  */
 public function render(\Magento\Framework\DataObject $row)
 {
     $value = $row->getData($this->getColumn()->getIndex());
     if ($this->stringHelper->strlen($value) > 30) {
         $value = '<span title="' . $this->escapeHtml($value) . '">' . $this->escapeHtml($this->filterManager->truncate($value, ['length' => 30])) . '</span>';
     } else {
         $value = $this->escapeHtml($value);
     }
     return $value;
 }

 /**
  * Get attribute type based on its backend model.
  * 
  * @param \Magento\Eav\Api\Data\AttributeInterface $attribute
  * @param string $serviceClass
  * @param $serviceBackendModelDataInterfaceMap array
  * @return string|null
  */
 public function getType($attribute, $serviceClass, $serviceBackendModelDataInterfaceMap)
 {
     $backendModel = $attribute->getBackendModel();
     //If empty backend model, check if it can be derived
     if (empty($backendModel)) {
         $backendModelClass = sprintf('Magento\\Eav\\Model\\Attribute\\Data\\%s', $this->stringUtility->upperCaseWords($attribute->getFrontendInput()));
         $backendModel = class_exists($backendModelClass) ? $backendModelClass : null;
     }
     $dataInterface = isset($serviceBackendModelDataInterfaceMap[$serviceClass][$backendModel]) ? $serviceBackendModelDataInterfaceMap[$serviceClass][$backendModel] : null;
     return $dataInterface;
 }

 /**
  * Validate SKU
  *
  * @param Product $object
  * @return bool
  * @throws \Magento\Framework\Exception\LocalizedException
  * @throws \Magento\Framework\Exception\LocalizedException
  */
 public function validate($object)
 {
     $attrCode = $this->getAttribute()->getAttributeCode();
     $value = $object->getData($attrCode);
     if ($this->getAttribute()->getIsRequired() && strlen($value) === 0) {
         throw new \Magento\Framework\Exception\LocalizedException(__('The value of attribute "%1" must be set', $attrCode));
     }
     if ($this->string->strlen($object->getSku()) > self::SKU_MAX_LENGTH) {
         throw new \Magento\Framework\Exception\LocalizedException(__('SKU length should be %1 characters maximum.', self::SKU_MAX_LENGTH));
     }
     return true;
 }

 /**
  * @dataProvider queryTextDataProvider
  */
 public function testGetEscapedQueryText($queryText, $maxQueryLength, $expected)
 {
     $this->requestMock->expects($this->once())->method('getParam')->willReturn($queryText);
     $this->stringMock->expects($this->any())->method('cleanString')->willReturnArgument(0);
     $this->scopeConfigMock->expects($this->any())->method('getValue')->willReturn($maxQueryLength);
     $this->stringMock->expects($this->any())->method('strlen')->will($this->returnCallback(function ($queryText) {
         return strlen($queryText);
     }));
     $this->stringMock->expects($this->any())->method('substr')->with($queryText, 0, $maxQueryLength)->willReturn($expected);
     $this->escaperMock->expects($this->any())->method('escapeHtml')->willReturnArgument(0);
     $this->assertEquals($expected, $this->model->getEscapedQueryText());
 }

 /**
  * @param mixed $attrCode
  * @param string $type
  * @return bool
  */
 protected function textValidation($attrCode, $type)
 {
     $val = $this->string->cleanString($this->_rowData[$attrCode]);
     if ($type == 'text') {
         $valid = $this->string->strlen($val) < Product::DB_MAX_TEXT_LENGTH;
     } else {
         $valid = $this->string->strlen($val) < Product::DB_MAX_VARCHAR_LENGTH;
     }
     if (!$valid) {
         $this->_addMessages([RowValidatorInterface::ERROR_EXCEEDED_MAX_LENGTH]);
     }
     return $valid;
 }

 /**
  * Special processing before attribute save:
  * a) check some rules for password
  * b) transform temporary attribute 'password' into real attribute 'password_hash'
  *
  * @param \Magento\Framework\DataObject $object
  * @return void
  * @throws \Magento\Framework\Exception\LocalizedException
  */
 public function beforeSave($object)
 {
     $password = $object->getPassword();
     $length = $this->string->strlen($password);
     if ($length > 0) {
         if ($length < self::MIN_PASSWORD_LENGTH) {
             throw new LocalizedException(__('Please enter a password with at least %1 characters.', self::MIN_PASSWORD_LENGTH));
         }
         if (trim($password) != $password) {
             throw new LocalizedException(__('The password can not begin or end with a space.'));
         }
         $object->setPasswordHash($object->hashPassword($password));
     }
 }

 /**
  * Load search results
  *
  * @return $this
  */
 public function load()
 {
     $result = [];
     if (!$this->hasStart() || !$this->hasLimit() || !$this->hasQuery()) {
         $this->setResults($result);
         return $this;
     }
     $collection = $this->queryFactory->get()->getSearchCollection()->addAttributeToSelect('name')->addAttributeToSelect('description')->addBackendSearchFilter($this->getQuery())->setCurPage($this->getStart())->setPageSize($this->getLimit())->load();
     foreach ($collection as $product) {
         $description = strip_tags($product->getDescription());
         $result[] = ['id' => 'product/1/' . $product->getId(), 'type' => __('Product'), 'name' => $product->getName(), 'description' => $this->string->substr($description, 0, 30), 'url' => $this->_adminhtmlData->getUrl('catalog/product/edit', ['id' => $product->getId()])];
     }
     $this->setResults($result);
     return $this;
 }

 public function testGetTooLongQuery()
 {
     $queryId = 123;
     $this->mapScopeConfig([self::XML_PATH_MAX_QUERY_LENGTH => 12]);
     $rawQueryText = 'This is very long search query text';
     $preparedQueryText = 'This is very';
     $this->stringMock->expects($this->once())->method('substr')->with($this->equalTo($rawQueryText))->will($this->returnValue($preparedQueryText));
     $this->requestMock->expects($this->once())->method('getParam')->with($this->equalTo(self::QUERY_VAR_NAME))->will($this->returnValue($rawQueryText));
     $this->objectManagerMock->expects($this->once())->method('create')->with($this->equalTo('Magento\\Search\\Model\\Query'))->will($this->returnValue($this->queryMock));
     $this->queryMock->expects($this->once())->method('loadByQuery')->with($this->equalTo($preparedQueryText))->will($this->returnSelf());
     $this->queryMock->expects($this->once())->method('getId')->will($this->returnValue($queryId));
     $this->queryMock->expects($this->once())->method('setIsQueryTextExceeded')->with($this->equalTo(true))->will($this->returnSelf());
     $query = $this->queryFactory->get();
     $this->assertSame($this->queryMock, $query);
 }

 /**
  * Create Form Element
  *
  * @param \Magento\Customer\Api\Data\AttributeMetadataInterface $attribute
  * @param string|int|bool $value
  * @param string $entityTypeCode
  * @param bool $isAjax
  * @return \Magento\Customer\Model\Metadata\Form\AbstractData
  */
 public function create(\Magento\Customer\Api\Data\AttributeMetadataInterface $attribute, $value, $entityTypeCode, $isAjax = false)
 {
     $dataModelClass = $attribute->getDataModel();
     $params = ['entityTypeCode' => $entityTypeCode, 'value' => is_null($value) ? false : $value, 'isAjax' => $isAjax, 'attribute' => $attribute];
     /** TODO fix when Validation is implemented MAGETWO-17341 */
     if ($dataModelClass == 'Magento\\Customer\\Model\\Attribute\\Data\\Postcode') {
         $dataModelClass = 'Magento\\Customer\\Model\\Metadata\\Form\\Postcode';
     }
     if (!empty($dataModelClass)) {
         $dataModel = $this->_objectManager->create($dataModelClass, $params);
     } else {
         $dataModelClass = sprintf('Magento\\Customer\\Model\\Metadata\\Form\\%s', $this->_string->upperCaseWords($attribute->getFrontendInput()));
         $dataModel = $this->_objectManager->create($dataModelClass, $params);
     }
     return $dataModel;
 }

 /**
  * Save rule labels for different store views
  *
  * @param int $ruleId
  * @param array $labels
  * @throws \Exception
  * @return $this
  */
 public function saveStoreLabels($ruleId, $labels)
 {
     $deleteByStoreIds = [];
     $table = $this->getTable('salesrule_label');
     $connection = $this->getConnection();
     $data = [];
     foreach ($labels as $storeId => $label) {
         if ($this->string->strlen($label)) {
             $data[] = ['rule_id' => $ruleId, 'store_id' => $storeId, 'label' => $label];
         } else {
             $deleteByStoreIds[] = $storeId;
         }
     }
     $connection->beginTransaction();
     try {
         if (!empty($data)) {
             $connection->insertOnDuplicate($table, $data, ['label']);
         }
         if (!empty($deleteByStoreIds)) {
             $connection->delete($table, ['rule_id=?' => $ruleId, 'store_id IN (?)' => $deleteByStoreIds]);
         }
     } catch (\Exception $e) {
         $connection->rollback();
         throw $e;
     }
     $connection->commit();
     return $this;
 }

 /**
  * Return variable value for var construction
  *
  * @param string $value raw parameters
  * @param string $default default value
  * @return string
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  */
 protected function getVariable($value, $default = '{no_value_defined}')
 {
     \Magento\Framework\Profiler::start('email_template_processing_variables');
     $tokenizer = new Template\Tokenizer\Variable();
     $tokenizer->setString($value);
     $stackVars = $tokenizer->tokenize();
     $result = $default;
     $last = 0;
     for ($i = 0; $i < count($stackVars); $i++) {
         if ($i == 0 && isset($this->templateVars[$stackVars[$i]['name']])) {
             // Getting of template value
             $stackVars[$i]['variable'] =& $this->templateVars[$stackVars[$i]['name']];
         } elseif (isset($stackVars[$i - 1]['variable']) && $stackVars[$i - 1]['variable'] instanceof \Magento\Framework\DataObject) {
             // If object calling methods or getting properties
             if ($stackVars[$i]['type'] == 'property') {
                 $caller = 'get' . $this->string->upperCaseWords($stackVars[$i]['name'], '_', '');
                 $stackVars[$i]['variable'] = method_exists($stackVars[$i - 1]['variable'], $caller) ? $stackVars[$i - 1]['variable']->{$caller}() : $stackVars[$i - 1]['variable']->getData($stackVars[$i]['name']);
             } elseif ($stackVars[$i]['type'] == 'method') {
                 // Calling of object method
                 if (method_exists($stackVars[$i - 1]['variable'], $stackVars[$i]['name']) || substr($stackVars[$i]['name'], 0, 3) == 'get') {
                     $stackVars[$i]['args'] = $this->getStackArgs($stackVars[$i]['args']);
                     $stackVars[$i]['variable'] = call_user_func_array([$stackVars[$i - 1]['variable'], $stackVars[$i]['name']], $stackVars[$i]['args']);
                 }
             }
             $last = $i;
         }
     }
     if (isset($stackVars[$last]['variable'])) {
         // If value for construction exists set it
         $result = $stackVars[$last]['variable'];
     }
     \Magento\Framework\Profiler::stop('email_template_processing_variables');
     return $result;
 }

 /**
  * Custom save logic for section
  *
  * @return void
  */
 protected function _saveSection()
 {
     $method = '_save' . $this->string->upperCaseWords($this->getRequest()->getParam('section'), '_', '');
     if (method_exists($this, $method)) {
         $this->{$method}();
     }
 }

 /**
  * Return formatted option value ready to edit, ready to parse
  *
  * @param string $optionValue Prepared for cart option value
  * @return string
  */
 public function getEditableOptionValue($optionValue)
 {
     $option = $this->getOption();
     $result = '';
     if (!$this->_isSingleSelection()) {
         foreach (explode(',', $optionValue) as $_value) {
             $_result = $option->getValueById($_value);
             if ($_result) {
                 $result .= $_result->getTitle() . ', ';
             } else {
                 if ($this->getListener()) {
                     $this->getListener()->setHasError(true)->setMessage($this->_getWrongConfigurationMessage());
                     $result = '';
                     break;
                 }
             }
         }
         $result = $this->string->substr($result, 0, -2);
     } elseif ($this->_isSingleSelection()) {
         $_result = $option->getValueById($optionValue);
         if ($_result) {
             $result = $_result->getTitle();
         } else {
             if ($this->getListener()) {
                 $this->getListener()->setHasError(true)->setMessage($this->_getWrongConfigurationMessage());
             }
             $result = '';
         }
     } else {
         $result = $optionValue;
     }
     return $result;
 }

 /**
  * Add meta information from product to head block
  *
  * @return \Magento\Catalog\Block\Product\View
  */
 protected function _prepareLayout()
 {
     $this->getLayout()->createBlock('Magento\\Catalog\\Block\\Breadcrumbs');
     $product = $this->getProduct();
     if (!$product) {
         return parent::_prepareLayout();
     }
     $title = $product->getMetaTitle();
     if ($title) {
         $this->pageConfig->getTitle()->set($title);
     }
     $keyword = $product->getMetaKeyword();
     $currentCategory = $this->_coreRegistry->registry('current_category');
     if ($keyword) {
         $this->pageConfig->setKeywords($keyword);
     } elseif ($currentCategory) {
         $this->pageConfig->setKeywords($product->getName());
     }
     $description = $product->getMetaDescription();
     if ($description) {
         $this->pageConfig->setDescription($description);
     } else {
         $this->pageConfig->setDescription($this->string->substr($product->getDescription(), 0, 255));
     }
     if ($this->_productHelper->canUseCanonicalTag()) {
         $this->pageConfig->addRemotePageAsset($product->getUrlModel()->getUrl($product, ['_ignore_category' => true]), 'canonical', ['attributes' => ['rel' => 'canonical']]);
     }
     $pageMainTitle = $this->getLayout()->getBlock('page.main.title');
     if ($pageMainTitle) {
         $pageMainTitle->setPageTitle($product->getName());
     }
     return parent::_prepareLayout();
 }

 /**
  * Group model factory
  *
  * @param string $type Option type
  * @return \Magento\Catalog\Model\Product\Option\Type\DefaultType
  * @throws LocalizedException
  */
 public function groupFactory($type)
 {
     $group = $this->getGroupByType($type);
     if (!empty($group)) {
         return $this->_optionFactory->create('Magento\\Catalog\\Model\\Product\\Option\\Type\\' . $this->string->upperCaseWords($group));
     }
     throw new LocalizedException(__('The option type to get group instance is incorrect.'));
 }