PHP Currency::getNewInstance方法代码示例

 public function testCreateAndRetrieve()
 {
     // set up currency
     if (ActiveRecord::objectExists('Currency', 'USD')) {
         $this->usd = Currency::getInstanceByID('USD', Currency::LOAD_DATA);
     } else {
         $this->usd = Currency::getNewInstance('USD');
         $this->usd->setAsDefault();
         $this->usd->save();
     }
     $products = array();
     for ($k = 0; $k <= 2; $k++) {
         $products[$k] = Product::getNewInstance($this->root);
         $products[$k]->setPrice($this->usd, $k + 1);
         $products[$k]->save();
         $bundled = ProductBundle::getNewInstance($this->container, $products[$k]);
         $bundled->save();
     }
     $list = ProductBundle::getBundledProductSet($this->container);
     $this->assertEqual($list->size(), count($products));
     foreach ($list as $index => $item) {
         $this->assertSame($item->relatedProduct->get(), $products[$index]);
     }
     $this->assertEqual(ProductBundle::getTotalBundlePrice($this->container, $this->usd), 6);
 }

 function testTransactionCurrencyConverting()
 {
     $eur = Currency::getNewInstance('EUR');
     $eur->rate->set('3.4528');
     $eur->save();
     $this->products[0]->setPrice($this->usd, '9.99');
     $this->order->addProduct($this->products[0], 1);
     $this->order->save();
     $this->order->changeCurrency($this->usd);
     //$this->order->finalize();
     ActiveRecord::clearPool();
     $order = CustomerOrder::getInstanceByID($this->order->getID(), true);
     $order->loadAll();
     $details = new LiveCartTransaction($order, $eur);
     ActiveRecord::clearPool();
     $order = CustomerOrder::getInstanceByID($this->order->getID(), true);
     $order->loadAll();
     $this->assertEquals($details->amount->get(), '2.89');
     $result = new TransactionResult();
     $result->amount->set($details->amount->get());
     $result->currency->set($details->currency->get());
     $transaction = Transaction::getNewInstance($order, $result);
     $transaction->type->set(Transaction::TYPE_SALE);
     $this->assertEquals($transaction->amount->get(), '9.99');
     $this->assertEquals($transaction->realAmount->get(), '2.89');
     $transaction->save();
     $this->assertFalse((bool) $order->isFinalized->get());
     $order->finalize();
     $this->assertTrue((bool) $order->isFinalized->get());
     $this->assertEquals($order->getPaidAmount(), '9.99');
     $this->assertEquals($order->totalAmount->get(), '9.99');
     $this->assertTrue((bool) $order->isPaid->get());
 }

 /**
  * !Running tests not involving initOrder() method will not recreate Currency,
  * but setUp() method is wiping all Currecy records,
  *
  * Store frontend is not working without Currency object
  *
  * As workround this method can be called from test suite to recreate Currency
  *
  * @todo: reorganize tests to call DELETE FROM Currency only when setUpCurrency() method is called.
  *
  */
 protected function setUpCurrency()
 {
     if (ActiveRecord::objectExists('Currency', 'USD')) {
         $this->usd = Currency::getInstanceByID('USD', Currency::LOAD_DATA);
     } else {
         $this->usd = Currency::getNewInstance('USD');
         $this->usd->setAsDefault();
         $this->usd->save();
     }
 }

 public function setUp()
 {
     parent::setUp();
     // create a product without attributes
     $this->product = Product::getNewInstance($this->category, 'test');
     $this->product->setValueByLang("name", "en", "TEST_PRODUCT");
     $this->product->save();
     $this->productAutoIncrementNumber = $this->product->getID();
     for ($k = 1; $k < 4; $k++) {
         $currency = Currency::getNewInstance($k . 'zz');
         $currency->save();
     }
 }

 public function ztestModelPlugins()
 {
     $this->getApplication()->registerPluginDirectory(ClassLoader::getRealPath('test.fixture.plugin'));
     $currency = Currency::getNewInstance('ZZZ');
     $currency->save();
     $this->assertEquals($currency->rate->get(), 0.5);
     $this->assertFalse((bool) $currency->isEnabled->get());
     $currency->rate->set(0.6);
     $currency->save();
     $this->assertTrue((bool) $currency->isEnabled->get());
     $array = $currency->toArray();
     $this->assertTrue($array['testValue']);
     $this->getApplication()->unregisterPluginDirectory(ClassLoader::getRealPath('test.fixture.plugin'));
 }

 protected function getInstance($record, CsvImportProfile $profile)
 {
     $fields = $profile->getSortedFields();
     if (isset($fields['Currency']['ID'])) {
         try {
             $instance = Currency::getInstanceByID($record[$fields['Currency']['ID']], true);
         } catch (ARNotFoundException $e) {
         }
     } else {
         return;
     }
     if (empty($instance)) {
         $instance = Currency::getNewInstance($record[$fields['Currency']['ID']]);
     }
     $this->setLastImportedRecordName($instance->getID());
     return $instance;
 }

 public function getNextCustomerOrder()
 {
     if (!($data = $this->loadRecord('SELECT * FROM ' . $this->getTablePrefix() . 'orders WHERE customerID > 0'))) {
         return null;
     }
     $user = ActiveRecordModel::getInstanceByIDIfExists('User', $this->getRealId('User', $data['customerID'], false));
     if (!$user || !$user->isExistingRecord()) {
         return $this->getNextCustomerOrder();
     }
     $currCode = $data['currency_code'];
     if (!($currency = ActiveRecordModel::getInstanceByIDIfExists('Currency', $currCode, false))) {
         $currency = Currency::getNewInstance($currCode);
         $currency->save();
     }
     $order = CustomerOrder::getNewInstance($user);
     $order->currency->set($currency);
     $order->dateCompleted->set($data['order_time']);
     // products
     foreach ($this->getDataBySql('SELECT * FROM ' . $this->getTablePrefix() . 'ordered_carts WHERE orderID=' . $data['orderID']) as $item) {
         $product = null;
         // try to identify product by SKU
         preg_match('/\\[(.*)\\]/', $item['name'], $sku);
         if (isset($sku[1])) {
             $product = Product::getInstanceBySKU($sku[1]);
         }
         // if that doesn't work, then try to match the exact name
         if (!$product) {
             $productData = array_shift($this->getDataBySQL('SELECT productID FROM ' . $this->getTablePrefix() . 'products WHERE name="' . addslashes($item['name']) . '"'));
             if ($productData && is_array($productData)) {
                 $product = Product::getInstanceByID($this->getRealId('Product', $productData['productID']), Product::LOAD_DATA);
             }
         }
         if ($product) {
             $order->addProduct($product, $item['Quantity'], true);
             $orderedItem = array_shift($order->getItemsByProduct($product));
             $orderedItem->price->set($item['Price']);
         }
     }
     // addresses
     $order->shippingAddress->set($this->getUserAddress($data, 'shipping_'));
     $order->billingAddress->set($this->getUserAddress($data, 'billing_'));
     $order->status->set($this->getOrderStatus($data['statusID']));
     if ($order->status->get() == CustomerOrder::STATUS_SHIPPED) {
         $order->isPaid->set(true);
     }
     $order->rawData = $data;
     return $order;
 }

 public function testMustHavePurchasedToRate()
 {
     $user = User::getNewInstance('i-want-to-rate@example.com');
     $user->save();
     self::getApplication()->getConfig()->set('ENABLE_REVIEWS', true);
     self::getApplication()->getConfig()->set('ENABLE_ANONYMOUS_RATINGS', false);
     self::getApplication()->getConfig()->set('REQUIRE_PURCHASE_TO_RATE', true);
     $this->request->set('rating_', 4);
     $this->request->set('ajax', 'true');
     $this->assertRatingError();
     $this->controller->setUser($user);
     // login not enough - should still fail
     $this->assertRatingError();
     ActiveRecordModel::executeUpdate('DELETE FROM Currency');
     $usd = Currency::getNewInstance('USD');
     $usd->save();
     $order = CustomerOrder::getNewInstance($user);
     $order->addProduct($this->product);
     $order->save();
     // order not completed - should still fail
     $this->assertRatingError();
     // order finalized - now works
     $order->finalize();
     $id = $this->product->getID();
     $this->setUp();
     $this->controller->setUser($user);
     $this->request->set('id', $id);
     $this->assertRatingError(false);
 }

 public function testOrderTotalsWithRoundedPrices()
 {
     $currency = Currency::getNewInstance('RON');
     $currency->setRoundingRule(0, Currency::TRIM, 0.09);
     $currency->save();
     $product = Product::getNewInstance(Category::getRootNode());
     $product->isEnabled->set(true);
     $product->setPrice($currency, 1.26);
     $product->save();
     $order = CustomerOrder::getNewInstance(SessionUser::getAnonymousUser());
     $order->addProduct($product);
     $order->save(true);
     $item = array_shift($order->getItemsByProduct($product));
     $this->assertEquals($product->getPrice($currency), 1.29);
     $this->assertEquals($item->getSubTotal(), 1.29);
     $item->count->set(2);
     $this->assertEquals($item->getSubTotal(), 2.58);
     $this->assertEquals($order->getTotal(true), 2.58);
     // add another currency to mix - no rounding rules
     $bgn = Currency::getNewInstance('BGN');
     $bgn->rate->set(2);
     $bgn->save();
     $item->count->set(2);
     $order->changeCurrency($bgn);
     $this->assertEquals($product->getPrice($bgn), 0.63);
     $this->assertEquals($item->getPrice(), 0.63);
     $this->assertSame($item->getCurrency(), $bgn);
     $this->assertEquals($item->getSubTotal(), 1.26);
     $this->assertEquals($order->getTotal(true), 1.26);
     // add rounding rules
     $bgn->clearRoundingRules();
     $bgn->setRoundingRule(0, Currency::TRIM, 0.07000000000000001);
     $order->changeCurrency($bgn);
     $this->assertEquals($product->getPrice($bgn), 0.67);
     $this->assertEquals($item->getSubTotal(), 1.34);
     $this->assertEquals($order->getTotal(true), 1.34);
 }