private function reloadOrder(CustomerOrder $order)
{
ActiveRecord::clearPool();
$order = CustomerOrder::getInstanceById($order->getID(), true);
$order->loadAll();
return $order;
}
public function set()
{
$request = $this->application->getRequest();
$parser = $this->getParser();
$apiFieldNames = $parser->getApiFieldNames();
$parser->loadDataInRequest($request);
$f = new ARSelectFilter();
$orderID = $request->get('orderID');
$shippingServiceID = $request->get('shippingServiceID');
if (intval($orderID) > 0) {
$f->mergeCondition(new EqualsCond(new ARFieldHandle('Shipment', 'orderID'), $orderID));
} else {
throw new Exception("Order ID is required");
}
$order = CustomerOrder::getInstanceById($orderID);
$order->load();
$order->loadAll();
$shipments = $order->getShipments();
foreach ($shipments as $key => $shipment) {
$shipment->setRateId($shippingServiceID);
}
$order->serializeShipments();
$order->save(true);
$response = new LiveCartSimpleXMLElement('<response datetime="' . date('c') . '"></response>');
return new SimpleXMLResponse($response);
}
/**
* Get CustomerOrder instance from session
*
* @return CustomerOrder
*/
public static function getOrder()
{
if (self::$instance) {
return self::$instance;
}
$session = new Session();
$id = $session->get('CustomerOrder');
if ($id) {
try {
$instance = CustomerOrder::getInstanceById($id, true);
if (!$instance->getOrderedItems()) {
$instance->loadItems();
}
$instance->isSyncedToSession = true;
} catch (ARNotFoundException $e) {
unset($instance);
}
}
if (!isset($instance)) {
$userId = SessionUser::getUser()->getID();
// get the last unfinalized order by this user
if ($userId > 0) {
$f = new ARSelectFilter(new EqualsCond(new ARFieldHandle('CustomerOrder', 'userID'), $userId));
$f->mergeCondition(new NotEqualsCond(new ARFieldHandle('CustomerOrder', 'isFinalized'), true));
$f->setOrder(new ARFieldHandle('CustomerOrder', 'ID'), 'DESC');
$f->setLimit(1);
$orders = ActiveRecordModel::getRecordSet('CustomerOrder', $f);
if ($orders->size()) {
$instance = $orders->get(0);
}
}
}
if (!isset($instance)) {
$instance = CustomerOrder::getNewInstance(User::getNewInstance(0));
$instance->user->set(NULL);
}
if (!$instance->user->get() && SessionUser::getUser()->getID() > 0) {
$instance->setUser(SessionUser::getUser());
$instance->save();
}
if ($instance->isFinalized->get()) {
$session->unsetValue('CustomerOrder');
return self::getOrder();
}
// fixes issue when trying to add OrderedItem to unsaved(without ID) CustomerOrder.
// ~ but i don't know if returning unsaved CustomerOrder is expected behaviour.
if ($instance->isExistingRecord() == false) {
$instance->save(true);
}
self::setOrder($instance);
return $instance;
}
function send()
{
$parser = $this->getParser();
$request = $this->application->getRequest();
$apiFieldNames = $parser->getApiFieldNames();
$orderID = $request->get('orderID');
$comment = $request->get('text');
if (!isset($orderID)) {
throw new Exception("Order ID is required");
}
if (!isset($comment)) {
throw new Exception("User comment is required");
}
$order = CustomerOrder::getInstanceById($orderID, CustomerOrder::LOAD_DATA);
$order->user->get()->load();
$note = OrderNote::getNewInstance($order, $order->user->get());
$note->isAdmin->set(false);
$note->text->set($comment);
$note->save();
$note->load(true);
/*if ($this->application->config->get('NOTIFY_NEW_NOTE'))
{
$order->user->get()->load();
$email = new Email($this->application);
$email->setTo($this->application->config->get('NOTIFICATION_EMAIL'), $this->application->config->get('STORE_NAME'));
$email->setTemplate('notify.message');
$email->set('order', $order->toArray(array('payments' => true)));
$email->set('message', $note->toArray());
$email->set('user', $order->user->toArray());
$email->send();
}*/
$f = new ARSelectFilter();
$f->mergeCondition(new EqualsCond(new ARFieldHandle('OrderNote', 'ID'), $note->getID()));
$orderNotes = ActiveRecordModel::getRecordSetArray('OrderNote', $f);
$response = new LiveCartSimpleXMLElement('<response datetime="' . date('c') . '"></response>');
while ($notes = array_shift($orderNotes)) {
$xmlPage = $response->addChild('note');
foreach ($notes as $k => $v) {
if (in_array($k, $apiFieldNames)) {
$xmlPage->addChild($k, htmlentities($v));
}
}
}
return new SimpleXMLResponse($response);
}
public function add()
{
if ($this->buildOrderNoteValidator()->isValid()) {
$order = CustomerOrder::getInstanceById($this->request->get('id'), CustomerOrder::LOAD_DATA);
$note = OrderNote::getNewInstance($order, $this->user);
$note->isAdmin->set(true);
$note->text->set($this->request->get('comment'));
$note->save();
if ($this->config->get('EMAIL_ORDERNOTE')) {
$order->user->get()->load();
$email = new Email($this->application);
$email->setUser($order->user->get());
$email->setTemplate('order.message');
$email->set('order', $order->toArray(array('payments' => true)));
$email->set('message', $note->toArray());
$email->send();
}
return new ActionRedirectResponse('backend.orderNote', 'view', array('id' => $note->getID()));
} else {
return new RawResponse('invalid');
}
}
public function index()
{
$response = new ActionResponse();
$customerOrder = CustomerOrder::getInstanceById($this->request->get('id'), true, array('User', 'Currency'));
$logs = array();
foreach (OrderLog::getRecordSetByOrder($customerOrder, null, array('User'))->toArray() as $entry) {
if (!$entry['oldValue']) {
$entry['oldValue'] = array();
}
if (!$entry['newValue']) {
$entry['newValue'] = array();
}
if ($entry['action'] != OrderLog::ACTION_REMOVED_WITH_SHIPMENT) {
$logs[] = $entry;
$logs[count($logs) - 1]['items'] = array();
} else {
$logs[count($logs) - 1]['items'][] = $entry;
}
}
$response->set('defaultCurrencyCode', $this->application->getDefaultCurrencyCode());
$response->set('logs', $logs);
return $response;
}
protected function getUpdateResponse()
{
/////// @todo - should be a better way for recalculating taxes...
ActiveRecord::clearPool();
$this->config->resetRuntime('DELIVERY_TAX_CLASS');
$this->order = CustomerOrder::getInstanceById($this->order->getID(), true);
///////
$this->order->loadAll();
$this->restoreShippingMethodSelection();
ActiveRecordModel::clearArrayData();
if ($paymentMethod = $this->session->get('OrderPaymentMethod_' . $this->order->getID())) {
$this->order->setPaymentMethod($paymentMethod);
$this->order->getTotal(true);
}
$this->setAnonAddresses();
// @todo: sometimes the shipping address disappears (for registered users that might already have the shipping address entered before)
if (!$this->order->shippingAddress->get() && $this->isShippingRequired($this->order) && $this->user->defaultShippingAddress->get()) {
$this->user->defaultShippingAddress->get()->load();
$this->order->shippingAddress->set($this->user->defaultShippingAddress->get()->userAddress->get());
$this->order->shippingAddress->get()->load();
}
$response = new CompositeJSONResponse();
$response->addAction('overview', 'onePageCheckout', 'overview');
$response->addAction('cart', 'onePageCheckout', 'cart');
if ($this->request->getActionName() != 'setPaymentMethod') {
$response->addAction('payment', 'onePageCheckout', 'payment');
}
$response->set('order', $this->getOrderValues($this->order));
foreach (func_get_args() as $arg) {
$response->addAction($arg, 'onePageCheckout', $arg);
}
$this->session->unsetValue('noJS');
$response = $this->postProcessResponse($response);
return $response;
}
public function testDefaultZoneVATWithAnotherZone()
{
TaxRate::getNewInstance(DeliveryZone::getDefaultZoneInstance(), $this->tax, 10)->save();
TaxRate::getNewInstance($this->deliveryZone, $this->tax, 10)->save();
DeliveryZoneCountry::getNewInstance($this->deliveryZone, 'US')->save();
$order = CustomerOrder::getNewInstance($this->user);
$order->addProduct($this->product, 1, true);
$order->currency->set($this->currency);
$order->shippingAddress->set($this->address);
$order->save();
$this->assertEqual($order->getTotal($this->currency), 100);
$order->finalize();
$this->assertDefaultZoneOrder($order, $this->currency);
ActiveRecord::clearPool();
$reloaded = CustomerOrder::getInstanceById($order->getID(), true);
$this->assertDefaultZoneOrder($reloaded, $this->currency);
}
public function cancelFurtherRebills()
{
ClassLoader::import('application.model.Currency');
ClassLoader::import('application.model.order.CustomerOrder');
ClassLoader::import('application.model.order.ExpressCheckout');
ClassLoader::import('application.model.order.Transaction');
ClassLoader::import('application.model.order.LiveCartTransaction');
$request = $this->getRequest();
$id = $request->get('id');
$page = $request->get('page');
$params = array('id' => $id);
if ($page > 1) {
$params['query'] = array('page' => $page);
}
$status = false;
$order = CustomerOrder::getInstanceById($id, true);
$userID = $this->user->getID();
if ($order->userID->get()->getID() && $order->userID->get()->getID() == $userID && true == $order->canUserCancelRebills()) {
$status = $order->cancelRecurring($this->getRequestCurrency());
if ($status != false) {
$order->cancelFurtherRebills();
}
}
if ($status == false) {
$this->setErrorMessage($this->translate('_cannot_cancel_subscription_contantc_store_administrator'));
}
return new ActionRedirectResponse('user', 'viewOrder', $params);
}
public function shipments()
{
$order = CustomerOrder::getInstanceById($this->request->get('id'), true, true);
return new ActionResponse("shipments", $this->getOrderShipments($order));
}
public function testShippingToMultipleAddresses()
{
$address1 = UserAddress::getNewInstance();
$address1->countryID->set('US');
$address1->save();
$address2 = UserAddress::getNewInstance();
$address2->countryID->set('CA');
$address2->save();
// zones, taxes and shipping rates
$zone1 = DeliveryZone::getNewInstance();
$zone1->isEnabled->set(true);
$zone1->name->set('USA');
$zone1->save();
DeliveryZoneCountry::getNewInstance($zone1, 'US')->save();
$zone2 = DeliveryZone::getNewInstance();
$zone2->isEnabled->set(true);
$zone2->name->set('Canada');
$zone2->save();
DeliveryZoneCountry::getNewInstance($zone2, 'CA')->save();
$tax = Tax::getNewInstance('VAT');
$tax->save();
TaxRate::getNewInstance($zone1, $tax, 20)->save();
TaxRate::getNewInstance($zone2, $tax, 15)->save();
$service = ShippingService::getNewInstance($zone1, 'def1', ShippingService::SUBTOTAL_BASED);
$service->save();
$shippingRate = ShippingRate::getNewInstance($service, 0, 10000000);
$shippingRate->flatCharge->set(100);
$shippingRate->save();
$service = ShippingService::getNewInstance($zone2, 'def2', ShippingService::SUBTOTAL_BASED);
$service->save();
$shippingRate = ShippingRate::getNewInstance($service, 0, 10000000);
$shippingRate->flatCharge->set(78);
$shippingRate->save();
// set up order
$this->order->isMultiAddress->set(true);
$this->order->save(true);
$product = $this->products[0];
$shipment1 = Shipment::getNewInstance($this->order);
$shipment1->shippingAddress->set($address1);
$shipment1->save();
$shipment2 = Shipment::getNewInstance($this->order);
$shipment2->shippingAddress->set($address2);
$shipment2->save();
$this->order->addProduct($product, 1, true, $shipment1);
$item = $this->order->addProduct($product, 1, true, $shipment2);
// edit amount after saving just to make things more complicated
$this->order->save();
$item->count->set(2);
// shipments shouldn't be reset like for regular orders
$this->assertEquals($this->order->getShipments()->size(), 2);
$price = $product->getPrice($this->usd);
$this->assertEquals($this->order->getTotal(true), $price * 1.2 + $price * 2 * 1.15);
// test if delivery zones are determined correctly
$this->assertEqual($shipment1->getDeliveryZone()->getID(), $zone1->getID());
// check if shipping rates are available
$this->assertEqual($shipment1->getShippingRates()->size(), 1);
$this->assertEqual($shipment1->getShippingRates()->get(0)->getCostAmount(), 100);
$this->assertEqual($shipment2->getShippingRates()->get(0)->getCostAmount(), 78);
foreach (array($shipment1, $shipment2) as $shipment) {
$shipment->setRateId($shipment->getShippingRates()->get(0)->getServiceID());
$shipment->recalculateAmounts();
$shipment->save();
}
$this->order->save();
$this->order->finalize();
// reload order
ActiveRecordModel::clearPool();
$order = CustomerOrder::getInstanceById($this->order->getID(), true);
$order->loadAll();
$this->assertEquals($order->getShipments()->size(), 2);
foreach ($order->getShipments() as $key => $shipment) {
$this->assertEquals(count($shipment->getItems()), 1);
$this->assertEquals(array_shift($shipment->getItems())->count->get(), $key + 1);
}
// order total with taxes and shipping
$this->assertEqual($order->getTotal(true), ($price + 100) * 1.2 + ($price * 2 + 78) * 1.15);
}
public function printInvoice()
{
$this->application->setTheme('');
$order = CustomerOrder::getInstanceById($this->request->get('id'), CustomerOrder::LOAD_DATA, CustomerOrder::LOAD_REFERENCES);
$order->loadAll();
if ($order->user->get()) {
$order->user->get()->getSpecification();
}
$this->setLayout('frontend');
$this->loadLanguageFile('Frontend');
$this->loadLanguageFile('User');
return new ActionResponse('order', $order->toArray(array('payments' => true)));
}
public function create()
{
$response = new LiveCartSimpleXMLElement('<response datetime="' . date('c') . '"></response>');
$request = $this->application->getRequest();
$orderID = $request->get('orderID');
$currencyID = $request->get('currencyID');
$amount = $request->get('amount');
$method = $request->get('method');
$gatewayTransactionID = $request->get('gatewayTransactionID');
if (intval($orderID) <= 0) {
throw new Exception('Order ID is required');
}
if (!isset($currencyID) || !isset($method) || !isset($gatewayTransactionID)) {
throw new Exception('Complete required fields : currencyID, method, gatewayTransactionID');
}
$transaction_result = new TransactionResult();
$transaction_result->currency->set($currencyID);
// = $currencyID;
$transaction_result->amount->set($amount);
//= $amount;
$transaction_result->gatewayTransactionID->set($gatewayTransactionID);
// = $gatewayTransactionID;
$transaction_result->setTransactionType(TransactionResult::TYPE_SALE);
$order = CustomerOrder::getInstanceById($orderID);
$order->loadAll();
$order_array = $order->toArray();
$user = User::getInstanceByID($order_array['userID']);
$user->load();
$order->user->set($user);
if ($current_transaction = Transaction::getInstance($order, $gatewayTransactionID)) {
$current_transaction->method->set($method);
$current_transaction->save();
} else {
$new_transaction = Transaction::getNewInstance($order, $transaction_result);
$new_transaction->method->set($method);
$new_transaction->save();
if (!$this->finalizeOrder($order, $user)) {
// Create new order for current user
$new_order = CustomerOrder::getNewInstance($user);
$new_order->beginTransaction();
$new_order->save();
$new_order->commit();
}
}
$parser = $this->getParser();
$apiFieldNames = $parser->getApiFieldNames();
$f = new ARSelectFilter();
$f->mergeCondition(new EqualsCond(new ARFieldHandle('Transaction', 'orderID'), $orderID));
$transactions = ActiveRecordModel::getRecordSetArray('Transaction', $f);
$response = new LiveCartSimpleXMLElement('<response datetime="' . date('c') . '"></response>');
if (false && count($transactions) == 0) {
throw new Exception('Transactions not found');
}
while ($transaction = array_shift($transactions)) {
$transaction_response = $response->addChild('transaction');
foreach ($transaction as $k => $v) {
if (in_array($k, $apiFieldNames)) {
$transaction_response->addChild($k, htmlentities($v));
}
}
}
return new SimpleXMLResponse($response);
}
public function changeOrderPaidStatus()
{
$order = CustomerOrder::getInstanceById($this->request->get('id'));
if (0 == $this->request->get('status')) {
foreach ($order->getTransactions() as $transaction) {
$transaction->void();
}
} else {
$transaction = Transaction::getNewOfflineTransactionInstance($order, $order->getDueAmount());
$transaction->user->set($this->user);
$transaction->save();
}
$order->isPaid->set($this->request->get('status') == true);
$order->save();
return new RawResponse();
}
public function delete_item()
{
$request = $this->application->getRequest();
$itemID = $request->get('ID');
$customerOrderID = $request->get('customerOrderID');
if (!isset($customerOrderID) && intval($customerOrderID == 0)) {
throw new Exception('Order ID is required');
}
if (!isset($itemID) && intval($itemID == 0)) {
throw new Exception('OrderedItem ID is required');
}
$item = ActiveRecordModel::getInstanceByID('OrderedItem', $itemID, ActiveRecordModel::LOAD_DATA, array('Product'));
$order = CustomerOrder::getInstanceById($customerOrderID);
$order->load(true);
$order->loadAll();
$order->removeItem($item);
$order->save(true);
$response = new LiveCartSimpleXMLElement('<response datetime="' . date('c') . '"></response>');
return new SimpleXMLResponse($response);
}
public function stopRebills($order = null)
{
if ($order === null) {
$request = $this->getRequest();
$id = $request->get('id');
$order = CustomerOrder::getInstanceById($id);
}
if ($this->canCancelRecurring($order)) {
$order->cancelFurtherRebills();
// localy in store database.
return new JSONResponse(array('recurringStatus' => $this->translate('_recurring_status_expired'), 'rebillCount' => 0), 'success');
}
return new JSONResponse(null, 'failure', $this->translate('_cannot_cancel_subscription'));
}
/**
* @role login
*/
public function completeExternal()
{
if (SessionOrder::getOrder()->getID() != $this->request->get('id')) {
SessionOrder::destroy();
}
$order = CustomerOrder::getInstanceById($this->request->get('id'), CustomerOrder::LOAD_DATA);
if ($order->user->get() != $this->user) {
throw new ApplicationException('Invalid order');
}
$this->session->set('completedOrderID', $order->getID());
return new ActionRedirectResponse('checkout', 'completed');
}
public function update()
{
$userID = $this->getApplication()->getRequest()->get('userID');
$orderID = $this->getApplication()->getRequest()->get('ID');
if (intval($userID) == 0 || intval($orderID) == 0) {
throw new Exception("User and Order ID not set");
}
$user = User::getInstanceByID($userID);
$order = CustomerOrder::getInstanceById($orderID);
$user->load();
$user->loadAddresses();
$order->loadAll();
return $this->apiActionGetOrdersBySelectFilter(select(eq(f('CustomerOrder.ID'), $this->getApplication()->getRequest()->get('ID'))));
}
public function testPaymentMethod()
{
ActiveRecordModel::getApplication()->getConfig()->setRuntime('INVENTORY_TRACKING', 'DISABLE');
$this->product1->isEnabled->set(true);
$this->product1->save();
$this->order->addProduct($this->product1, 1);
$this->order->save();
ActiveRecord::clearPool();
$this->order = CustomerOrder::getInstanceById($this->order->getID(), true);
$this->order->loadAll();
$this->assertEquals(1, $this->order->getShoppingCartItemCount());
$condition = DiscountCondition::getNewInstance();
$condition->isEnabled->set(true);
$condition->conditionClass->set('RuleConditionPaymentMethodIs');
$condition->addValue('TESTING');
$condition->save();
$this->assertEquals(0, count($this->order->getDiscountConditions(true)));
$this->order->setPaymentMethod('TESTING');
$this->assertEquals(1, count($this->order->getDiscountConditions(true)));
$this->order->setPaymentMethod('AnotherOne');
$this->assertEquals(0, count($this->order->getDiscountConditions(true)));
// test finalized order
ClassLoader::import('library.payment.TransactionResult');
$transResult = new TransactionResult();
$transResult->setTransactionType(TransactionResult::TYPE_SALE);
$transResult->amount->set(10000);
$transResult->currency->set('USD');
$transaction = Transaction::getNewInstance($this->order, $transResult);
$transaction->method->set('TESTING');
$transaction->save();
$this->order->finalize();
ActiveRecord::clearPool();
$reloaded = CustomerOrder::getInstanceById($this->order->getID(), true);
$reloaded->loadAll();
$this->assertTrue($reloaded->isExistingRecord());
$this->assertEquals(1, $reloaded->getShoppingCartItemCount());
$this->assertEquals(1, count($reloaded->getDiscountConditions(true)));
$condition->removeValue('TESTING');
$condition->addValue('Whatever');
$condition->save();
$this->assertEquals(0, count($reloaded->getDiscountConditions(true)));
}
