public function testCreate() { $session = $this->getTestSession(); $this->assertTrue(0 < $session->getId(), 'check session id'); foreach ($this->testSession as $k => $v) { $m = 'get' . \XLite\Core\Converter::convertToCamelCase($k); $this->assertEquals($v, $session->{$m}(), 'Check ' . $k); } }
/** * testCreate * * @return void * @see ____func_see____ * @since 1.0.22 */ public function testCreate() { $method = $this->getTestMethod(); $this->assertTrue(0 < $method->getMethodId(), 'check method id'); foreach ($this->testMethod as $k => $v) { $m = 'get' . \XLite\Core\Converter::convertToCamelCase($k); $this->assertEquals($v, $method->{$m}(), 'Check ' . $k); } }
/** * Get entity value * * @return mixed */ protected function getEntityValue() { $result = null; $entity = $this->getEntity(); $method = 'get' . \XLite\Core\Converter::convertToCamelCase($this->getParam(static::PARAM_FIELD_NAME)); if (method_exists($entity, $method)) { // $method assembled from 'get' + field short name $result = $this->getEntity()->{$method}(); } return $result; }
/** * Preprocessor for no-action run * * @return void */ protected function doNoAction() { $dictionary = \XLite\Core\Request::getInstance()->dictionary; if ($dictionary) { $method = 'assembleDictionary' . \XLite\Core\Converter::convertToCamelCase($dictionary); if (method_exists($this, $method)) { $this->data = $this->processData($this->{$method}(strval(\XLite\Core\Request::getInstance()->erm))); } } $this->silent = true; }
public function testCreate() { $group = $this->getTestGroup(); $this->assertEquals(3, count($group->getOptions()), 'Check options count'); $options = $group->getOptions(); $option = $options[0]; foreach ($this->testOption as $k => $v) { $m = 'get' . \XLite\Core\Converter::convertToCamelCase($k); $this->assertEquals($v, $option->{$m}(), 'Check ' . $k . ' (option)'); } $this->assertEquals(10, $options[2]->getSurcharge('price')->getModifier(), 'Check modifier'); $this->assertEquals('$', $options[2]->getSurcharge('price')->getModifierType(), 'Check modifier type'); $this->assertEquals(1, $options[2]->getExceptions()->count(), 'Check exceptions'); }
/** * Add options to HTML Purifier config * * @param \HTMLPurifier_Config $config Config instance * * @return \HTMLPurifier_Config */ public static function addConfigOptions($config, $options) { foreach ($options as $name => $value) { if ('1' == $value) { $value = true; } elseif ('0' == $value) { $value = false; } $method = 'prepareOptionValue' . \XLite\Core\Converter::convertToCamelCase(str_replace('.', '', $name)); if (method_exists(static::getInstance(), $method)) { $value = static::$method($value); } if (!is_null($value)) { $config->set($name, $value); } } $config = static::postprocessOptions($config, $options); return $config; }
/** * testCreate * * @return void * @see ____func_see____ * @since 1.0.13 */ public function testCreate() { $c = $this->currency; $this->assertTrue(0 < $c->getCurrencyId(), 'check currency id'); foreach ($this->testData as $k => $v) { $m = 'get' . \XLite\Core\Converter::convertToCamelCase($k); $this->assertEquals($v, $c->{$m}(), 'Check ' . $k); } $o = $this->getTestOrder(); $o->setCurrency($c); $c->addOrders($o); $this->assertEquals($o, $c->getOrders()->get(0), 'check order'); try { $this->getTestCurrency(true); $this->fail('check code unique failed'); } catch (\PDOException $e) { $this->assertRegExp('/SQLSTATE\\[23000\\]/', $e->getMessage(), 'check code unique'); } }
/** * Define columns * * @return array */ protected function defineColumns() { $columns = array('orderNumber' => array(), static::CUSTOMER_PREFIX . 'Email' => array(), static::CUSTOMER_PREFIX . 'Anonymous' => array(), static::CUSTOMER_PREFIX . 'AddressSame' => array()); foreach (\XLite\Core\Database::getRepo('XLite\\Model\\AddressField')->findAllEnabled() as $field) { $name = ucfirst(\XLite\Core\Converter::convertToCamelCase($field->getServiceName())); $columns[static::CUSTOMER_PREFIX . $name . 'Billing' . static::ADDRESS_FIELD_SUFFIX] = array(static::COLUMN_GETTER => 'getBillingAddressFieldValue', static::COLUMN_FORMATTER => 'formatBillingAddressFieldValue', 'service_name' => $field->getServiceName()); } foreach (\XLite\Core\Database::getRepo('XLite\\Model\\AddressField')->findAllEnabled() as $field) { $name = ucfirst(\XLite\Core\Converter::convertToCamelCase($field->getServiceName())); $columns[static::CUSTOMER_PREFIX . $name . 'Shipping' . static::ADDRESS_FIELD_SUFFIX] = array(static::COLUMN_GETTER => 'getShippingAddressFieldValue', static::COLUMN_FORMATTER => 'formatShippingAddressFieldValue', 'service_name' => $field->getServiceName()); } $columns += array(static::ITEM_PREFIX . 'Name' => array(static::COLUMN_MULTIPLE => true), static::ITEM_PREFIX . 'SKU' => array(static::COLUMN_MULTIPLE => true), static::ITEM_PREFIX . 'Attributes' => array(static::COLUMN_MULTIPLE => true), static::ITEM_PREFIX . 'Price' => array(static::COLUMN_MULTIPLE => true), static::ITEM_PREFIX . 'Quantity' => array(static::COLUMN_MULTIPLE => true), static::ITEM_PREFIX . 'Subtotal' => array(static::COLUMN_MULTIPLE => true)); foreach ($this->getOrderItemSurchargeTypes() as $type) { $columns[$type['name'] . ' (item surcharge)'] = array('type' => $type, static::COLUMN_GETTER => 'getOrderItemSurchargeColumnValue', static::COLUMN_MULTIPLE => true); } $columns += array(static::ITEM_PREFIX . 'Total' => array(static::COLUMN_MULTIPLE => true), 'subtotal' => array()); foreach ($this->getOrderSurchargeTypes() as $type) { $columns[$type['name'] . ' (surcharge)'] = array('type' => $type, static::COLUMN_GETTER => 'getOrderSurchargeColumnValue'); } $columns += array('total' => array(), 'currency' => array(), 'shippingMethod' => array(), 'trackingNumber' => array(), static::PAYMENT_TRANSACTION_PREFIX . 'Method' => array(static::COLUMN_MULTIPLE => true), static::PAYMENT_TRANSACTION_PREFIX . 'Status' => array(static::COLUMN_MULTIPLE => true), static::PAYMENT_TRANSACTION_PREFIX . 'Value' => array(static::COLUMN_MULTIPLE => true), static::PAYMENT_TRANSACTION_PREFIX . 'Note' => array(static::COLUMN_MULTIPLE => true), static::PAYMENT_TRANSACTION_PREFIX . 'Type' => array(static::COLUMN_MULTIPLE => true), static::PAYMENT_TRANSACTION_PREFIX . 'Id' => array(static::COLUMN_MULTIPLE => true), static::PAYMENT_TRANSACTION_PREFIX . 'Data' => array(static::COLUMN_MULTIPLE => true), 'date' => array(), 'paymentStatus' => array(), 'shippingStatus' => array(), 'notes' => array(), 'adminNotes' => array(), 'detailCode' => array(static::COLUMN_MULTIPLE => true), 'detailLabel' => array(static::COLUMN_MULTIPLE => true), 'detailValue' => array(static::COLUMN_MULTIPLE => true)); return $columns; }
/** * testConstruct * * @return void * @access public * @see ____func_see____ * @since 1.0.0 */ public function testConstruct() { $dataToSet = array(); $dataToCheck = array(); foreach ($this->getProductData() as $key => $data) { list($actual, $expected) = $data; $dataToSet[$key] = $actual; $dataToCheck[$key] = isset($expected) ? $expected : $actual; } $entity = new \XLite\Model\Product($dataToSet); foreach ($dataToCheck as $key => $value) { $this->assertEquals($value, $entity->{'get' . \XLite\Core\Converter::convertToCamelCase($key)}(), 'Field "' . $key . '" does not match'); } // Order item $i = new \XLite\Model\OrderItem(); $entity->addOrderItems($i); $this->assertEquals($i, $entity->getOrderItems()->get(0), 'check order item'); // Image $i = new \XLite\Model\Image\Product\Image(); $entity->addImages($i); $this->assertEquals($i, $entity->getImages()->get(0), 'check image'); }
/** * testCreate * * @return void * @access public * @see ____func_see____ * @since 1.0.0 */ public function testCreate() { $order = $this->getTestOrder(); $this->assertTrue(0 < $order->getOrderId(), 'check order id'); foreach ($order as $k => $v) { $m = 'get' . \XLite\Core\Converter::convertToCamelCase($k); $this->assertEquals($v, $order->{$m}(), 'Check test order: ' . $k); } $this->assertEquals($this->getProduct()->getProductId(), $order->getItems()->get(0)->getObject()->getProductId(), 'check product id'); $this->assertEquals('Purchase Order', $order->getPaymentMethod()->getName(), 'check payment method'); $this->assertFalse(is_null($order->getProfile()), 'check profile'); $this->assertFalse(is_null($order->getProfile()->getOrder()), 'check profile\'s order'); $this->assertEquals($order->getOrderId(), $order->getProfile()->getOrder()->getOrderId(), 'check profile\'s order id'); $this->assertTrue(0 < $order->getDate(), 'check date'); $shippingCost = $order->getSurchargeSumByType('shipping'); $this->assertEquals(1, $order->getItems()->get(0)->getAmount(), 'check quantity'); $this->assertEquals($this->getProduct()->getPrice(), $order->getItems()->get(0)->getPrice(), 'check price'); $this->assertEquals($this->getProduct()->getPrice(), $order->getItems()->get(0)->getSubtotal(), 'check item subtotal'); $this->assertEquals($this->getProduct()->getPrice(), $order->getSubtotal(), 'check order subtotal'); $this->assertEquals(round($shippingCost + $this->getProduct()->getPrice(), 2), $order->getTotal(), 'check total'); // Payment method $pm = \XLite\Core\Database::getRepo('XLite\\Model\\Payment\\Method')->findOneBy(array('service_name' => 'PurchaseOrder')); $order->setPaymentMethod($pm); $this->assertEquals($pm, $order->getPaymentMethod(), 'check payment method'); // Saved modifiers $surcharge = new \XLite\Model\Order\Surcharge(); $surcharge->setType('shipping'); $surcharge->setCode('ttt'); $surcharge->setValue(10.0); $surcharge->setInclude(false); $surcharge->setAvailable(true); $surcharge->setClass(get_called_class()); $surcharge->setName('test'); $order->getSurcharges()->add($surcharge); $surcharge->setOwner($order); $count = count($order->getSurcharges()); $this->assertEquals($surcharge, $order->getSurcharges()->get($count - 1), 'check surcharge'); }
/** * Get help * * @return string */ protected function getHelp() { $help = null; $action = \XLite\Core\Request::getInstance()->action; if ($action) { $method = 'getHelp' . \XLite\Core\Converter::convertToCamelCase($action); $help = method_exists($this, $method) ? $this->{$method}() : 'Action \'' . $action . '\' has not help note'; } else { $help = $this->getControllerHelp(); } return $help; }
/** * Create field widget * * @param string $name Field name * @param array $data Field data * * @return \XLite\View\FormField\AFormField */ protected function getFieldBySchema($name, array $data) { $result = null; $class = $data[\XLite\View\Model\Address\Address::SCHEMA_CLASS]; if (\XLite\Core\Operator::isClassExists($class)) { $method = 'prepareFieldParams' . \XLite\Core\Converter::convertToCamelCase($name); if (method_exists($this, $method)) { $data = $this->{$method}($data); } $result = new $class($this->getFieldSchemaArgs($name, $data)); } return $result; }
/** * Preprocess option change and return true on success * * @param \XLite\Model\Config $option Option entity * * @return boolean */ protected function preprocessOption($option) { $result = true; $method = 'preprocess' . \XLite\Core\Converter::convertToCamelCase($option->name) . 'Option'; if (method_exists($this, $method)) { $result = $this->{$method}($option); } return $result; }
/** * Postprocess surcharge * * @param float $surcharge Surcharge * * @return mixed */ protected function postprocessSurcharge($surcharge) { static $methodNames = array(); $type = $this->getType(); if (!isset($methodNames[$type])) { $name = 'postprocessSurcharge' . \XLite\Core\Converter::convertToCamelCase($this->getType()); $methodNames[$type] = method_exists($this, $name) ? $name : false; } return $methodNames[$type] ? $this->{$methodNames[$type]}($surcharge) : $surcharge; }
/** * Calculated and create Canada Post parcels for the order * * @param boolean $replace Flag - replace order's parcels or not * * @return void */ public function createCapostParcels($replace = false) { $modifier = $this->getModifier(\XLite\Model\Base\Surcharge::TYPE_SHIPPING, 'SHIPPING'); $rawPackages = $modifier && $modifier->getMethod() && $modifier->getMethod()->getProcessorObject() ? $modifier->getMethod()->getProcessorObject()->getPackages($modifier) : array(); $capostConfig = \XLite\Core\Config::getInstance()->XC->CanadaPost; if ($replace) { // Remove order's parcels $this->removeAllCapostParcels(); } if (!empty($rawPackages) && is_array($rawPackages)) { foreach ($rawPackages as $packageIdx => $package) { $parcel = new \XLite\Module\XC\CanadaPost\Model\Order\Parcel(); $parcel->setOrder($this); $parcel->setNumber($packageIdx + 1); $parcel->setQuoteType($capostConfig->quote_type); // Set parcel box dimensions and weight foreach (array('weight', 'length', 'width', 'height') as $_param) { $parcel->{'setBox' . \XLite\Core\Converter::convertToCamelCase($_param)}($package['box'][$_param]); } // Set parcel types (DEFAULT) foreach (array('document', 'unpackaged', 'mailing_tube', 'oversized') as $_param) { $parcel->{'setIs' . \XLite\Core\Converter::convertToCamelCase($_param)}($capostConfig->{$_param}); } // Set default parcel options (from the module settings) $optClasses = $parcel->getAllowedOptionClasses(); foreach ($optClasses as $optClass => $classData) { if ($parcel::OPT_CLASS_COVERAGE == $optClass) { // Do not use default settings for "coverage" continue; } // Set default option value from module settings $value = isset($capostConfig->{$optClass}) ? $capostConfig->{$optClass} : ''; if ($classData[$parcel::OPT_SCHEMA_MULTIPLE] && $classData[$parcel::OPT_SCHEMA_MANDATORY] && !isset($classData[$parcel::OPT_SCHEMA_ALLOWED_OPTIONS][$value])) { // Set allowed option value $value = array_shift(array_keys($classData[$parcel::OPT_SCHEMA_ALLOWED_OPTIONS])); } $parcel->{'setOpt' . \XLite\Core\Converter::convertToCamelCase($optClass)}($value); } // Add items to the parcel foreach ($package['items'] as $itemIdx => $item) { $parcelItem = new \XLite\Module\XC\CanadaPost\Model\Order\Parcel\Item(); $parcelItem->setAmount($item['qty']); $parcelItem->setOrderItem($this->getItemById($item['id'])); // Assign parcel to the order $parcel->addItem($parcelItem); } // Assign parcel to the order $this->addCapostParcel($parcel); \XLite\Core\Database::getEM()->persist($parcel); } \XLite\Core\Database::getEM()->flush(); } }
/** * Get timestamp of current day start * * @return integer */ protected function getStartTime($interval = self::P_ALL) { $methodName = 'get' . \XLite\Core\Converter::convertToCamelCase($interval) . 'StartTime'; return method_exists($this, $methodName) ? call_user_func(array($this, $methodName)) : $this->getDefaultStartTime(); }
/** * Get model value by name * * @param \XLite\Model\AEntity $model Model object * @param string $name Property name * * @return mixed */ protected function getModelValue($model, $name) { $method = 'get' . \XLite\Core\Converter::convertToCamelCase($name); // $method - assemble from 'get' + property name return $model->{$method}(); }
/** * Convert XML files name to camel case * * @param string $field XML field name * * @return string */ public static function convertXmlFieldToCamelCase($field) { return lcfirst(\XLite\Core\Converter::convertToCamelCase(str_replace('-', '_', $field))); }
/** * Truncates the baseObject property value to specified length * * @param mixed $base String or object instance to get field value from * @param mixed $field String length or field to get value * @param integer $length Field length to truncate to OPTIONAL * @param string $etc String to add to truncated field value OPTIONAL * @param mixed $breakWords Word wrap flag OPTIONAL * * @return string */ protected function truncate($base, $field, $length = 0, $etc = '...', $breakWords = false) { if (is_scalar($base)) { $string = $base; $length = $field; } else { if ($base instanceof \XLite\Model\AEntity) { $string = $base->{'get' . \XLite\Core\Converter::convertToCamelCase($field)}(); } else { $string = $base->get($field); } } if (0 == $length) { $string = ''; } elseif (strlen($string) > $length) { $length -= strlen($etc); if (!$breakWords) { $string = preg_replace('/\\s+?(\\S+)?$/', '', substr($string, 0, $length + 1)); } $string = substr($string, 0, $length) . $etc; } return $string; }
/** * getFieldBySchema * TODO - should use the Factory class * * @param string $name Field name * @param array $data Field description * * @return \XLite\View\FormField\AFormField */ protected function getFieldBySchema($name, array $data) { $class = $data[self::SCHEMA_CLASS]; $method = 'prepareFieldParams' . \XLite\Core\Converter::convertToCamelCase($name); if (method_exists($this, $method)) { // Call the corresponded method $this->{$method}($data); } return new $class($this->getFieldSchemaArgs($name, $data)); }
/** * testCreate * * @return void * @see ____func_see____ * @since 1.0.22 */ public function testCreate() { $group = $this->getTestGroup(); $this->assertTrue(0 < $group->getGroupId(), 'check group id type'); foreach ($this->testGroup as $k => $v) { $m = 'get' . \XLite\Core\Converter::convertToCamelCase($k); $this->assertEquals($v, $group->{$m}(), 'Check ' . $k); } $this->assertEquals($this->getProduct()->getProductId(), $group->getProduct()->getProductId(), 'check product id'); $this->assertEquals(1, count($group->getOptions()), 'Check options count'); $options = $group->getOptions(); $option = $options[0]; foreach ($this->testOption as $k => $v) { $m = 'get' . \XLite\Core\Converter::convertToCamelCase($k); $this->assertEquals($v, $option->{$m}(), 'Check ' . $k . ' (option)'); } }
/** * test * * @return void * @access public * @see ____func_see____ * @since 1.0.0 */ public function testInsert() { $data = array('enabled' => false, 'name' => 'Test category', 'cleanURL' => 'test_cat'); $entity = $this->getRepo()->insert($data); $entity->setParent($this->getRepo()->find(14016)); $this->assertInstanceOf('\\XLite\\Model\\Category', $entity, 'Created entity must be of the "\\XLite\\Model\\Category" type'); foreach ($data as $name => $value) { $this->assertEquals($value, $entity->{'get' . \XLite\Core\Converter::convertToCamelCase($name)}(), 'The "' . $name . '" property of the created entity must be equal to "' . $value . '"'); } }
/** * Main 'Select' action handler. * - calls "doActionSelect<file_select_action><object><file_object>()" handler * - set return URL which is set by "getParamsObject<object>()" getter * * @return void */ protected function doActionSelect() { $actionName = 'doActionSelect' . \XLite\Core\Converter::convertToCamelCase(\XLite\Core\Request::getInstance()->file_select) . \XLite\Core\Converter::convertToCamelCase($this->getObjectTarget()) . \XLite\Core\Converter::convertToCamelCase(\XLite\Core\Request::getInstance()->fileObject); if (method_exists($this, $actionName)) { call_user_func(array($this, $actionName)); } $returnURL = $this->forceReturnURL ?: $this->buildURL($this->getRedirectTarget(), '', $this->getParamsObject()); $this->setReturnURL($returnURL); }
/** * Get product data as REST * * @param integer $id Product id * * @return array */ public function getProductREST($id) { $product = $this->find($id); $data = null; if ($product) { foreach ($this->_class->fieldNames as $name) { $mname = 'get' . \XLite\Core\Converter::convertToCamelCase($name); // $maname assebmled from 'get' + \XLite\Core\Converter::convertToCamelCase() method $data[$name] = $product->{$mname}(); } $data['name'] = $product->getName(); $data['description'] = $product->getDescription(); } return $data; }
/** * Get cell cache parameters converter method name * * @param string $name Cell name * * @return string */ protected function getCacheParamsConverterName($name) { return 'convertRecordToParams' . \XLite\Core\Converter::convertToCamelCase($name); }
/** * Call "Get Maifest" request * * @return boolean */ public function callApiGetManifest() { $result = false; $data = \XLite\Module\XC\CanadaPost\Core\API::getInstance()->callGetManifestRequest($this); if (isset($data->errors)) { // Save errors $this->apiCallErrors = $data->errors; } else { sleep(2); // to get Canada Post server time to generate PDF documents $this->setPoNumber($data->poNumber); foreach ($data->links as $link) { $manifestLink = new \XLite\Module\XC\CanadaPost\Model\Order\Parcel\Manifest\Link(); $manifestLink->setManifest($this); $this->addLink($manifestLink); foreach (array('rel', 'href', 'mediaType', 'idx') as $linkField) { if (isset($link->{$linkField})) { $manifestLink->{'set' . \XLite\Core\Converter::convertToCamelCase($linkField)}($link->{$linkField}); } } if (!$manifestLink->callApiGetArtifact() && $manifestLink->getApiCallErrors()) { // Error is occurred while downloading PDF documents if (!isset($this->apiCallErrors)) { $this->apiCallErrors = array(); } $this->apiCallErrors += $manifestLink->getApiCallErrors(); } } \XLite\Core\Database::getEM()->flush(); $result = true; } return $result; }
/** * Get model value by name * * @param \XLite\Model\AEntity $model Model object * @param string $name Property name * * @return mixed */ protected function getModelValue($model, $name) { $method = 'get' . \XLite\Core\Converter::convertToCamelCase($name); // $method - assemble from 'get' + property name return method_exists($model, $method) ? $model->{$method}() : ($model->isPropertyExists($name) ? $model->getterProperty($name) : null); }
/** * Prepare column handler * * @param array $column Column info * @param string $name Column cell name * @param string $pattern Handler name pattern * * @return mixed */ protected function prepareColumnHandler(array $column, $name, $pattern) { $result = null; if (empty($column[$name])) { $uname = \XLite\Core\Converter::convertToCamelCase($column[static::COLUMN_NAME]); $method = str_replace('{name}', $uname, $pattern); if (method_exists($this, $method)) { $result = $method; } } elseif (true === $column[$name]) { $uname = \XLite\Core\Converter::convertToCamelCase($column[static::COLUMN_NAME]); $result = str_replace('{name}', $uname, $pattern); } elseif (is_callable($column[$name])) { $result = $column[$name]; } return $result; }
/** * Get create line columns * * @return array */ protected function getCreateColumns() { $columns = array(); if ($this->getLeftActions()) { $columns[] = array(static::COLUMN_CODE => 'actions left', static::COLUMN_NAME => '', static::COLUMN_SERVICE => true, static::COLUMN_TEMPLATE => 'items_list/model/table/parts/empty_left.tpl'); } foreach ($this->defineColumns() as $idx => $column) { if (isset($column[static::COLUMN_CREATE_CLASS]) && $column[static::COLUMN_CREATE_CLASS] || isset($column[static::COLUMN_CLASS]) && $column[static::COLUMN_CLASS]) { $column[static::COLUMN_CODE] = $idx; $column[static::COLUMN_METHOD_SUFFIX] = \XLite\Core\Converter::convertToCamelCase($column[static::COLUMN_CODE]); if (!isset($column[static::COLUMN_CREATE_CLASS]) || !$column[static::COLUMN_CREATE_CLASS]) { $column[static::COLUMN_CREATE_CLASS] = $column[static::COLUMN_CLASS]; } $columns[] = $column; } else { $columns[] = array(static::COLUMN_CODE => $idx, static::COLUMN_TEMPLATE => 'items_list/model/table/empty.tpl'); } } if ($this->getRightActions()) { $columns[] = array(static::COLUMN_CODE => 'actions right', static::COLUMN_NAME => '', static::COLUMN_SERVICE => true, static::COLUMN_TEMPLATE => $this->isRemoved() ? 'items_list/model/table/parts/remove_create.tpl' : 'items_list/model/table/parts/empty_right.tpl'); } return $columns; }
/** * Get entity * * @return \XLite\Model\AEntity */ public function getEntity() { $entity = null; foreach (\XLite\Model\Repo\CleanURL::getEntityTypes() as $type) { $method = 'get' . \XLite\Core\Converter::convertToCamelCase($type); if (method_exists($this, $method)) { $entity = $this->{$method}(); if ($entity) { break; } } } return $entity; }