PHP Category::getRootNode方法代码示例

 private function getFilterUrlTemplate()
 {
     include_once ClassLoader::getRealPath('application.helper.smarty') . '/function.categoryUrl.php';
     $params = array('filters' => array(new ManufacturerFilter(999, '___')), 'data' => Category::getRootNode()->toArray());
     $templateUrl = createCategoryUrl($params, $this->application);
     return strtr($templateUrl, array(999 => '#', '___' => '|'));
 }

 public function testDelete()
 {
     $type = ProductRatingType::getNewInstance(Category::getRootNode());
     $type->save();
     $type2 = ProductRatingType::getNewInstance(Category::getRootNode());
     $type2->save();
     for ($k = 0; $k <= 1; $k++) {
         $review = ProductReview::getNewInstance($this->product, $this->user);
         $review->save();
         $rating = ProductRating::getNewInstance($this->product, $type);
         $rating->rating->set(6 + $k);
         $rating->review->set($review);
         $rating->save();
         $rating = ProductRating::getNewInstance($this->product, $type2);
         $rating->rating->set(4 + $k);
         $rating->review->set($review);
         $rating->save();
     }
     $this->product->reload();
     $this->assertEqual($this->product->ratingCount->get(), 4);
     $this->assertEqual($this->product->ratingSum->get(), 22);
     $this->assertEqual($this->product->rating->get(), 5.5);
     // delete last review
     $review->delete();
     $this->product->reload();
     $this->assertEqual($this->product->ratingCount->get(), 2);
     $this->assertEqual($this->product->ratingSum->get(), 10);
     $this->assertEqual($this->product->rating->get(), 5);
     // check rating summaries
     $summary = ProductRatingSummary::getInstance($this->product, $type2);
     $this->assertEqual($summary->rating->get(), 4);
 }

/**
 * Generates manufacturer page URL
 *
 * @param array $params
 * @param Smarty $smarty
 * @return string
 *
 * @package application.helper.smarty
 * @author Integry Systems
 */
function smarty_function_manufacturerUrl($params, LiveCartSmarty $smarty)
{
    $manufacturer = $params['data'];
    $params['data'] =& Category::getRootNode()->toArray();
    $params['addFilter'] = new ManufacturerFilter($manufacturer['ID'], $manufacturer['name']);
    return createCategoryUrl($params, $smarty->getApplication());
}

 public function products()
 {
     $this->setLayout('empty');
     set_time_limit(0);
     $response = new XMLResponse();
     $filter = new ARSelectFilter();
     $filter->setOrder(f('Product.dateCreated'), ARSelectFilter::ORDER_DESC);
     $categoryId = $this->getRequest()->get('id');
     if (preg_match('/^\\d+$/', $categoryId)) {
         $this->shouldBeEnabledFeed('CATEGORY_PRODUCTS');
         $category = Category::getInstanceById($categoryId, Category::LOAD_DATA);
         $filter = new ProductFilter($category, $filter);
     } else {
         $this->shouldBeEnabledFeed('ALL_PRODUCTS');
         $category = Category::getRootNode(true);
         $filter = new ProductFilter($category, $filter);
         $filter->includeSubCategories();
     }
     $feed = new ProductFeed($filter);
     $feed->setFlush();
     $feed->setLimit($this->config->get('NUMBER_OF_PRODUCTS_TO_INCLUDE'));
     $response->set('feed', $feed);
     $response->set('category', $category->toArray());
     return $response;
 }

 public function testRatingTypes()
 {
     $type = ProductRatingType::getNewInstance(Category::getRootNode());
     $type->save();
     $rating = ProductRating::getNewInstance($this->product, $type);
     $rating->rating->set(6);
     $rating->save();
     $this->product->reload();
     $this->assertEqual($this->product->ratingCount->get(), 1);
     $this->assertEqual($this->product->ratingSum->get(), 6);
     $this->assertEqual($this->product->rating->get(), 6);
     ActiveRecord::clearPool();
     $summary = ProductRatingSummary::getInstance($this->product, $type);
     $summary->reload();
     $this->assertEqual($summary->ratingCount->get(), 1);
     $this->assertEqual($summary->ratingSum->get(), 6);
     $this->assertEqual($summary->rating->get(), 6);
     $type2 = ProductRatingType::getNewInstance(Category::getRootNode());
     $type2->save();
     $rating = ProductRating::getNewInstance($this->product, $type2);
     $rating->rating->set(4);
     $rating->save();
     $this->product->reload();
     $this->assertEqual($this->product->ratingCount->get(), 2);
     $this->assertEqual($this->product->ratingSum->get(), 10);
     $this->assertEqual($this->product->rating->get(), 5);
     ActiveRecord::clearPool();
     $summary = ProductRatingSummary::getInstance($this->product, $type2);
     $summary->reload();
     $this->assertEqual($summary->ratingCount->get(), 1);
     $this->assertEqual($summary->ratingSum->get(), 4);
     $this->assertEqual($summary->rating->get(), 4);
 }

 /**
  * Products popup
  *
  * @role update
  */
 public function selectProduct()
 {
     $response = new ActionResponse();
     $categoryList = Category::getRootNode()->getDirectChildNodes();
     $categoryList->unshift(Category::getRootNode());
     $response->set("categoryList", $categoryList->toArray());
     return $response;
 }

 public function setUp()
 {
     parent::setUp();
     $this->root = Category::getRootNode();
     $this->container = Product::getNewInstance($this->root);
     $this->container->type->set(Product::TYPE_BUNDLE);
     $this->container->save();
 }

 public function testPositions()
 {
     $type1 = ProductRatingType::getNewInstance(Category::getRootNode());
     $type1->save();
     $type2 = ProductRatingType::getNewInstance(Category::getRootNode());
     $type2->save();
     $this->assertEqual($type1->position->get(), 1);
     $this->assertEqual($type2->position->get(), 2);
 }

 public function testContaining()
 {
     $root = Category::getRootNode();
     $list = ProductList::getNewInstance($root);
     $list->save();
     $product = Product::getNewInstance($root);
     $product->save();
     $list->addProduct($product);
     $another = Product::getNewInstance($root);
     $another->save();
     $this->assertTrue($list->contains($product));
     $this->assertFalse($list->contains($another));
 }

 public function setUp()
 {
     parent::setUp();
     $this->product = Product::getNewInstance(Category::getRootNode(), 'test');
     $this->product->save();
     $this->option = ProductOption::getNewInstance($this->product);
     $this->option->type->set(ProductOption::TYPE_SELECT);
     $this->option->save();
     for ($k = 0; $k <= 1; $k++) {
         $choice = ProductOptionChoice::getNewInstance($this->option);
         $choice->priceDiff->set(10 + $k);
         $choice->save();
         $this->choices[] = $choice;
     }
 }

 public function setUp()
 {
     parent::setUp();
     Category::recalculateProductsCount();
     $this->root = Category::getNewInstance(Category::getRootNode());
     $this->root->save();
     for ($k = 1; $k <= 2; $k++) {
         $cat = Category::getNewInstance($this->root);
         $cat->save();
         $this->categories[$k] = $cat;
     }
     $this->product = Product::getNewInstance($this->categories[1]);
     $this->product->save();
     $this->secondCategory = ProductCategory::getNewInstance($this->product, $this->categories[2]);
     $this->secondCategory->save();
 }

 public function testDelete()
 {
     $category = Category::getNewInstance(Category::getRootNode());
     $category->save();
     $field = SpecField::getNewInstance($category, SpecField::DATATYPE_TEXT, SpecField::TYPE_TEXT_SIMPLE);
     $field->handle->set('randomhandle');
     $field->save();
     $this->request->set('id', $field->getID());
     $response = $this->controller->delete();
     $this->assertIsA($response, 'JSONResponse');
     $value = $response->getValue();
     $this->assertEqual($value['status'], 'success');
     // already deleted
     $response = $this->controller->delete();
     $value = $response->getValue();
     $this->assertEqual($value['status'], 'failure');
 }

 private function createOrder()
 {
     $user = User::getNewInstance('google@checkout.test');
     $user->save();
     $currency = Currency::getInstanceByID('USD');
     $product = Product::getNewInstance(Category::getRootNode());
     $product->isEnabled->set(true);
     $product->stockCount->set(100);
     $product->setPrice($currency, 100);
     $product->setValueByLang('name', null, 'Test name');
     $product->setValueByLang('shortDescription', null, 'Really short description');
     $product->save();
     $order = CustomerOrder::getNewInstance($user);
     $order->addProduct($product, 1);
     $order->save();
     return $order;
 }

 public function testRatingTypes()
 {
     $types = array();
     for ($k = 1; $k <= 3; $k++) {
         $type = ProductRatingType::getNewInstance(Category::getRootNode());
         $type->save();
         $types[$k] = $type;
         $this->request->set('rating_' . $type->getID(), $k);
     }
     $this->controller->rate();
     $this->product->reload();
     $response = $this->controller->index();
     $ratings = $response->get('rating');
     $this->assertEqual(count($ratings), 3);
     foreach ($ratings as $key => $rating) {
         $this->assertEqual($key + 1, $rating['rating']);
     }
 }

 public function export()
 {
     $module = $this->request->get('module');
     $enabledFeeds = $this->config->get('ENABLED_FEEDS');
     if (!isset($enabledFeeds[$module]) || $this->request->get('key') != $this->config->get('FEED_KEY')) {
         return;
     }
     $this->setLayout('empty');
     set_time_limit(0);
     $cat = Category::getRootNode(true);
     $filter = new ProductFilter($cat, new ARSelectFilter());
     $filter->includeSubCategories();
     $feed = new ProductFeed($filter);
     $feed->setFlush();
     $response = new XMLResponse();
     $response->set('feed', $feed);
     $response->set('tpl', 'xml/feed/' . $module . '.tpl');
     return $response;
 }