/**
* Update payment method
*
* @return void
*/
protected function doActionUpdate()
{
$settings = \XLite\Core\Request::getInstance()->settings;
$method = $this->getPaymentMethod();
if (!$method) {
\XLite\Core\TopMessage::addError('An attempt to update settings of unknown payment method');
} else {
if (is_array($settings)) {
foreach ($settings as $name => $value) {
$method->setSetting($name, trim($value));
}
}
$properties = \XLite\Core\Request::getInstance()->properties;
if (is_array($properties) && !empty($properties)) {
$method->map($properties);
}
\XLite\Core\Database::getRepo('\\XLite\\Model\\Payment\\Method')->update($method);
// If "just added" method is configured and can be enabled then we enable it
if (\XLite\Core\Request::getInstance()->just_added && $method->isConfigured() && $method->canEnable()) {
$method->setEnabled(true);
\XLite\Core\Database::getEM()->flush();
}
if ($method->isConfigured()) {
\XLite\Core\TopMessage::addInfo('The settings of payment method successfully updated');
$this->setReturnURL($this->buildURL('payment_settings'));
} else {
\XLite\Core\TopMessage::addWarning('Payment method has not been configured properly');
}
}
}
/**
* Execute certain hook handle
*
* @return void
*/
public function executeHookHandler()
{
if (\XLite\Upgrade\Cell::getInstance()->isUpgraded()) {
$entries = \XLite\Upgrade\Cell::getInstance()->getEntries();
if ($entries) {
\Includes\Utils\Operator::showMessage('', true, false);
/** @var \XLite\Upgrade\Entry\AEntry $entry */
foreach ($entries as $entry) {
if (!$entry->isPostUpgradeActionsCalled()) {
$message = '...Invoke actions for ' . $entry->getActualName();
\Includes\Decorator\Utils\CacheManager::logMessage(PHP_EOL);
\Includes\Decorator\Utils\CacheManager::logMessage($message);
$isInvoked = \XLite\Upgrade\Cell::getInstance()->runHelper($entry, 'post_rebuild');
if ($isInvoked && \XLite\Upgrade\Cell::getInstance()->getHookRedirect()) {
break;
}
if (!\XLite\Upgrade\Cell::getInstance()->hasUnfinishedUpgradeHooks('post_rebuild', $entry)) {
// All post-rebuild hooks completed, run the rest actions...
\XLite\Upgrade\Cell::getInstance()->runCommonHelper($entry, 'add_labels');
\XLite\Upgrade\Cell::getInstance()->callInstallEvent($entry);
$entry->setPostUpgradeActionsCalled();
}
if (\Includes\Decorator\Utils\CacheManager::isTimeExceeds(static::STEP_TTL)) {
break;
}
}
}
}
}
\Includes\Decorator\Utils\CacheManager::logMessage(PHP_EOL);
\XLite\Core\Database::getEM()->flush();
\XLite\Core\Database::getEM()->clear();
}
/**
* Run task
*
* @return void
*/
protected function doActionRun()
{
$event = \XLite\Core\Request::getInstance()->event;
$result = false;
$errors = array();
$task = \XLite\Core\Database::getRepo('XLite\\Model\\EventTask')->findOneBy(array('name' => $event));
if ($task) {
if (\XLite\Core\EventListener::getInstance()->handle($task->getName(), $task->getArguments())) {
\XLite\Core\Database::getEM()->remove($task);
$result = true;
}
$errors = \XLite\Core\EventListener::getInstance()->getErrors();
} else {
\XLite\Core\Database::getRepo('XLite\\Model\\TmpVar')->removeEventState($event);
}
\XLite\Core\Database::getEM()->flush();
$state = \XLite\Core\Database::getRepo('XLite\\Model\\TmpVar')->getEventState($event);
$this->setPureAction(true);
if ($result && $state) {
\XLite\Core\Event::eventTaskRun(array('percent' => \XLite\Core\Database::getRepo('XLite\\Model\\TmpVar')->getEventStatePercent($event), 'error' => !empty($errors)));
} else {
$result = false;
}
if ($errors) {
foreach ($errors as $message) {
\XLite\Core\TopMessage::addError($message);
}
$result = false;
}
$this->valid = $result;
}
/**
* @param bool $new_order
* @return XLite\Model\Order
*/
protected function getTestOrder($new_order = false)
{
$order = parent::getTestOrder($new_order);
$order->setPaymentMethod($this->getTestMethod());
\XLite\Core\Database::getEM()->flush();
return $order;
}
/**
* testCreate
*
* @return void
* @access public
* @see ____func_see____
* @since 1.0.0
*/
public function testCreate()
{
$c = new \XLite\Model\Country();
foreach ($this->entityData as $field => $testValue) {
$setterMethod = 'set' . \XLite\Core\Converter::getInstance()->convertToCamelCase($field);
$getterMethod = 'get' . \XLite\Core\Converter::getInstance()->convertToCamelCase($field);
$c->{$setterMethod}($testValue);
$value = $c->{$getterMethod}();
$this->assertEquals($testValue, $value, 'Creation checking (' . $field . ')');
}
$s = new \XLite\Model\State();
$s->setState('test state');
$s->setCode('ttt');
$c->addStates($s);
$em = \XLite\Core\Database::getEM();
$em->persist($c);
$em->flush();
$em->clear();
$c = \XLite\Core\Database::getEM()->merge($c);
foreach ($this->entityData as $field => $testValue) {
$getterMethod = 'get' . \XLite\Core\Converter::getInstance()->convertToCamelCase($field);
$this->assertEquals($testValue, $c->{$getterMethod}(), 'Creation checking (' . $field . ') #2');
}
$this->assertEquals($s->getStateId(), $c->getStates()->get(0)->getStateId(), 'check state');
$em->remove($c);
$em->flush();
}
/**
* Update membership list
*
* @return void
*/
protected function doActionUpdate()
{
$data = \XLite\Core\Request::getInstance()->update_memberships;
if (!is_array($data)) {
// TODO - add top message
} else {
$code = $this->getCurrentLanguage();
$flag = false;
foreach ($data as $id => $row) {
$m = \XLite\Core\Database::getRepo('\\XLite\\Model\\Membership')->find($id);
if ($m) {
$duplicate = \XLite\Core\Database::getRepo('\\XLite\\Model\\Membership')->createQueryBuilder()->andWhere('translations.name = :name', 'm.membership_id != :id')->setParameter('name', $row['name'])->setParameter('id', $id)->setMaxResults(1)->getSingleResult();
if (!is_null($duplicate)) {
\XLite\Core\TopMessage::addWarning('"' . $row['name'] . '" ' . ' membership name is already in use. ' . 'Please specify another name for this membership level');
} else {
\XLite\Core\Database::getRepo('\\XLite\\Model\\Membership')->update($m, $row);
}
$flag = true;
} else {
\XLite\Core\TopMessage::addError('Could not find membership ID#' . $id . ' record in the database');
}
}
if ($flag) {
\XLite\Core\Database::getEM()->flush();
}
}
}
/**
* Update user's Drupal roles
*
* @param array $newDrupalRoles Array of Drupal role IDs
*
* @return void
*/
public function updateDrupalRoles($newDrupalRoles)
{
$processedRoles = array();
$drupalRoles = $this->getDrupalRoles();
if ($drupalRoles) {
// Remove roles that is not in new roles array
foreach ($this->getDrupalRoles() as $key => $drupalRole) {
if (!in_array($drupalRole->getDrupalRoleId(), $newDrupalRoles)) {
$this->drupalRoles->remove($key);
\XLite\Core\Database::getEM()->remove($drupalRole);
} else {
$processedRoles[] = $drupalRole->getDrupalRoleId();
}
}
}
// Get roles to add
$rolesToAdd = array_diff($newDrupalRoles, $processedRoles);
// Create new roles
foreach ($rolesToAdd as $roleId) {
$newDrupalRole = new \XLite\Module\CDev\DrupalConnector\Model\DrupalRole();
$newDrupalRole->setProfile($this);
$newDrupalRole->setDrupalRoleId($roleId);
$this->addDrupalRoles($newDrupalRole);
}
}
/**
* Action of license key registration
*
* @return void
*/
protected function doActionRegisterKey()
{
$key = \XLite\Core\Request::getInstance()->key;
$addonsInfo = \XLite\Core\Marketplace::getInstance()->checkAddonKey($key);
if ($addonsInfo && $addonsInfo[$key]) {
$addonsInfo = $addonsInfo[$key];
$repo = \XLite\Core\Database::getRepo('\\XLite\\Model\\ModuleKey');
foreach ($addonsInfo as $info) {
$module = \XLite\Core\Database::getRepo('\\XLite\\Model\\Module')->findOneBy(array('author' => $info['author'], 'name' => $info['name']));
if ($module) {
$entity = $repo->findKey($info['author'], $info['name']);
if ($entity) {
$entity->setKeyValue($key);
$repo->update($entity);
} else {
$entity = $repo->insert($info + array('keyValue' => $key));
}
\XLite\Core\Database::getEM()->flush();
// Clear cache for proper installation
\XLite\Core\Marketplace::getInstance()->clearActionCache(\XLite\Core\Marketplace::ACTION_GET_ADDONS_LIST);
$this->showInfo(__FUNCTION__, 'License key has been successfully verified for "{{name}}" module by "{{author}}" author', array('name' => $module->getModuleName(), 'author' => $module->getAuthorName()));
} else {
$this->showError(__FUNCTION__, 'Key is validated, but the module [' . implode(',', $info) . '] was not found');
}
}
} else {
$error = \XLite\Core\Marketplace::getInstance()->getError();
if ($error) {
$this->showError(__FUNCTION__, 'Response from marketplace: ' . $error);
} else {
$this->showError(__FUNCTION__, 'Response from marketplace is not received');
}
}
$this->setReturnURL($this->buildURL('addons_list_marketplace'));
}
public function testGetTotalRate()
{
$tax = \XLite\Core\Database::getRepo('XLite\\Module\\CDev\\VAT\\Model\\Tax')->getTax();
foreach ($tax->getRates() as $rate) {
\XLite\Core\Database::getEM()->remove($rate);
}
$tax->getRates()->clear();
$tax->setEnabled(true);
$rate = new \XLite\Module\CDev\VAT\Model\Tax\Rate();
$rate->setValue(10);
$rate->setPosition(1);
\XLite\Core\Database::getEM()->persist($rate);
$tax->addRates($rate);
$rate->setTax($tax);
$rate = new \XLite\Module\CDev\VAT\Model\Tax\Rate();
$rate->setValue(20);
$rate->setPosition(0);
\XLite\Core\Database::getEM()->persist($rate);
$tax->addRates($rate);
$rate->setTax($tax);
$memberships = \XLite\Core\Database::getRepo('XLite\\Model\\Membership')->findAll();
$membership = array_shift($memberships);
$rate->setMembership($membership);
$tax->setVATMembership($membership);
\XLite\Core\Database::getEM()->flush();
$method = new \XLite\Model\Shipping\Method();
$method->setEnabled(true);
$rate = new \XLite\Model\Shipping\Rate();
$rate->setBaseRate(10);
$rate->setMarkupRate(10);
$rate->setMethod($method);
$this->assertEquals(16.67, \XLite::getInstance()->getCurrency()->formatValue($rate->getTotalRate()), 'check cost');
}
/**
* Execute certain hook handler
*
* @return void
*/
public function executeHookHandler()
{
\XLite\Core\Translation::getInstance()->reset();
\XLite\Core\Database::getEM()->flush();
\XLite\Core\Translation::getInstance()->resetDriver();
\XLite\Core\Translation::getInstance()->translateByString('label');
\XLite\Core\Database::getRepo('XLite\\Model\\TmpVar')->setVar(\XLite::CACHE_TIMESTAMP, intval(microtime(true)));
}
/**
* Sync amount in stock with remaining pin codes
*
* @return void
*/
public function syncAmount()
{
$remaining = $this->getProduct()->getRemainingPinCodesCount();
if (parent::getAmount() !== $remaining) {
$this->setAmount($remaining);
\XLite\Core\Database::getEM()->persist($this);
}
}
/**
* Create tax
*
* @return \XLite\Module\CDev\SalesTax\Model\Tax
*/
protected function createTax()
{
$tax = new \XLite\Module\CDev\SalesTax\Model\Tax();
$tax->setName('Sales tax');
$tax->setEnabled(true);
\XLite\Core\Database::getEM()->persist($tax);
return $tax;
}
/**
* Set order note
*
* @return void
*/
public function doActionSetOrderNote()
{
if (isset(\XLite\Core\Request::getInstance()->notes)) {
$this->getCart()->setNotes(\XLite\Core\Request::getInstance()->notes);
}
\XLite\Core\Database::getEM()->flush();
exit;
}
protected function getTestOrder($new_order = false)
{
$order = parent::getTestOrder($new_order);
$order->setDetail('t1', '123');
$order->setDetail('t2', '456', 'test');
\XLite\Core\Database::getEM()->flush();
return $order;
}
/**
* Fire event
*
* @param string $name Event name
* @param array $arguments Arguments OPTIONAL
*
* @return boolean
*/
public function fire($name, array $arguments = array())
{
$entity = new \XLite\Model\EventTask();
$entity->setName($name);
$entity->setArguments($arguments);
\XLite\Core\Database::getEM()->persist($entity);
\XLite\Core\Database::getEM()->flush();
}
/**
* setUp
*
* @return void
* @access protected
* @see ____func_see____
* @since 1.0.0
*/
protected function setUp()
{
parent::setUp();
\XLite\Core\Database::getEM()->clear();
$this->doRestoreDb(__DIR__ . '/sql/profile/setup.sql', false);
$this->testSearchData[22]['cnd']['startDate'] = date('M j, Y', time() - 60 * 60 * 24 * 7);
$this->testSearchData[22]['cnd']['endDate'] = date('M j, Y', time() - 60 * 60 * 24 * 3);
}
/**
* Read storage
*
* @param \XLite\Model\Base\Storage $storage Storage
*
* @return void
*/
protected function readStorage(\XLite\Model\Base\Storage $storage)
{
if ($this->storageKey) {
$this->storageKey->incrementAttempt();
\XLite\Core\Database::getEM()->flush();
}
parent::readStorage($storage);
}
public function storeCachedSearch($query, $result)
{
$searchCache = new \XLite\Module\QSL\CloudSearch\Model\SearchCache();
$searchCache->setKeyValue($this->getKey($query));
$searchCache->setResultValue($result);
$searchCache->setActualTime(LC_START_TIME + static::TTL);
\XLite\Core\Database::getEM()->persist($searchCache);
\XLite\Core\Database::getEM()->flush($searchCache);
}
/**
* Remove temporary order
*
* @param \XLite\Model\Order $order Order
*
* @return void
*/
protected function removeTemporaryOrder(\XLite\Model\Order $order)
{
foreach ($order->getItems() as $item) {
foreach ($item->getPinCodes() as $pin) {
\XLite\Core\Database::getEM()->remove($pin);
}
}
parent::removeTemporaryOrder($order);
}
/**
* Run step
*
* @return void
*/
protected function runStep()
{
$listener = \XLite\Core\EventListener::getInstance();
foreach (\XLite\Core\Database::getRepo('XLite\\Model\\EventTask')->findQuery() as $task) {
if ($listener->handle($task->getName(), $task->getArguments())) {
\XLite\Core\Database::getEM()->remove($task);
}
}
}
/**
* Delete single entity
*
* @param \XLite\Model\AEntity $entity Entity to detach
*
* @return void
*/
protected function performDelete(\XLite\Model\AEntity $entity)
{
parent::performDelete($entity);
if (is_subclass_of(get_class($entity), 'XLite\\Model\\AttributeValue\\Multiple')) {
\XLite\Core\Database::getEM()->persist($entity);
\XLite\Core\Database::getEM()->flush();
$entity->getProduct()->checkVariants();
}
}
/**
* testDelete
*
* @return void
* @see ____func_see____
* @since 1.0.22
*/
public function testDelete()
{
$method = $this->getTestMethod();
$id = $method->getMethodId();
\XLite\Core\Database::getEM()->remove($method);
\XLite\Core\Database::getEM()->flush();
$method = \XLite\Core\Database::getRepo('XLite\\Model\\Payment\\Method')->find($id);
$this->assertNull($method, 'check removed method');
}
protected function getEM()
{
if ($this->entityManager == null) {
$this->entityManager = \XLite\Core\Database::getEM();
}
if (!$this->entityManager->isOpen()) {
$this->entityManager = $this->entityManager->create($this->entityManager->getConnection(), $this->entityManager->getConfiguration());
}
return $this->entityManager;
}
protected function getTestLowInventoryOrder()
{
$order = \XLite\Core\Database::getRepo('XLite\\Model\\Order')->createQueryBuilder()->setMaxResults(1)->getQuery()->getSingleResult();
$order->setStatus('Q');
$item = $order->getItems()->get(0);
$inv = $item->getProduct()->getInventory();
$inv->setEnabled(true);
$inv->setAmount(0);
\XLite\Core\Database::getEM()->flush();
return $order;
}
protected function getTestAttachment()
{
$product = $this->getProduct();
$attach = new \XLite\Module\CDev\FileAttachments\Model\Product\Attachment();
$product->addAttachments($attach);
$attach->setProduct($product);
$storage = $attach->getStorage();
$this->assertTrue($storage->loadFromLocalFile(__DIR__ . LC_DS . 'max_ava.png'), 'check loading');
\XLite\Core\Database::getEM()->flush();
return $attach;
}
public function testDelete()
{
$method = $this->getTestMethod();
$s = $method->getSettings()->get(0);
$id = $s->getSettingId();
$method->getSettings()->removeElement($s);
\XLite\Core\Database::getEM()->remove($s);
\XLite\Core\Database::getEM()->flush();
$s = \XLite\Core\Database::getRepo('XLite\\Model\\Payment\\MethodSetting')->find($id);
$this->assertNull($s, 'check removed setting');
}
/**
* Find and remove expired tracking details
*
* @return void
*/
public function removeExpired()
{
$list = $this->findAllExpiredDetails();
if (count($list)) {
foreach ($list as $tracking) {
\XLite\Core\Database::getEM()->remove($tracking);
}
\XLite\Core\Database::getEM()->flush();
\XLite\Core\Database::getEM()->clear();
}
}
/**
* Get attribute value data
*
* @param array $data Import row data
* @param \XLite\Model\Attribute $attribute Attribute object
*
* @return array
*/
protected function getAttributeValueData($data, $attribute)
{
$option = \XLite\Core\Database::getRepo('XLite\\Model\\AttributeOption')->findOneByNameAndAttribute($data['value'], $attribute);
if (!$option) {
$option = new \XLite\Model\AttributeOption();
$option->setAttribute($attribute);
$option->setName($data['value']);
\XLite\Core\Database::getEM()->persist($option);
}
return array('attribute_option' => $option);
}
/**
* testFindZone
*
* @return void
* @access public
* @see ____func_see____
* @since 1.0.0
*/
public function testFindZone()
{
$zone = \XLite\Core\Database::getRepo('XLite\\Model\\Zone')->findOneBy(array('zone_name' => 'New York area'));
$this->assertTrue($zone instanceof \XLite\Model\Zone, 'check zone');
$id = $zone->getZoneId();
\XLite\Core\Database::getEM()->clear();
$zone = \XLite\Core\Database::getRepo('XLite\\Model\\Zone')->findZone($id);
$this->assertTrue($zone instanceof \XLite\Model\Zone, 'findZone(20) must return an instance of \\XLite\\Model\\Zone');
$zone = \XLite\Core\Database::getRepo('XLite\\Model\\Zone')->findZone(20000);
$this->assertNull($zone, 'findZone(20000) must return null');
}
/**
* Check if the disabled category is shown as usual category page.
*
* @return void
* @access protected
* @since 1.0.7
*/
public function testDisabledCategory()
{
$categories = \XLite\Core\Database::getRepo('XLite\\Model\\Category')->findByEnabled(true);
$category = $categories[3];
$category->setEnabled(false);
\XLite\Core\Database::getEM()->persist($category);
\XLite\Core\Database::getEM()->flush();
$url = $this->getCategoryURL($category->getCategoryId());
$this->openAndWait($url);
$this->assertElementPresent('//h2[@class="page-not-found"]', 'Category ' . $category->getCategoryId() . ' must be disabled');
}
