<?php
 
class Mm_Service_Order
{
    protected $_orderModel;
 
    protected $_orderModelOptions;
 
    protected $_orderMapper;
 
    protected $_itemMapper;
 
    public function __construct($options = array())
    {
        $this->_orderModelOptons = $options;
    }
 
    public function getOrderModelOptions()
    {
        return $this->_orderModelOptions;
    }
 
    public function setOrderModelOptions(array $options)
    {
        $this->_orderModelOptions = $options;
    }
 
    public function getOrderModel($newInstance = true)
    {
        if ($newInstance) {
            return new Mm_Model_Order(
                $this->getOrderModelOptions()
            );
        }
 
        if (null === $this->_orderModel) {
            $this->setOrderModel(new Mm_Model_Order(
                $this->getOrderModelOptions()
            ));
        }
        return $this->_orderModel;
    }
 
    public function setOrderModel($model)
    {
        $this->_orderModel = $model;
    }
 
    public function getOrderMapper($newInstance = true)
    {
        if ($newInstance) {
            return new Mm_Model_OrderMapper();
        }
 
        if (null === $this->_orderMapper) {
            $this->setOrderMapper(new Mm_Model_OrderMapper());
        }
        return $this->_orderMapper;
    }
 
    public function setOrderMapper($mapper)
    {
        $this->_orderMapper = $mapper;
    }
 
    /**
     * Returns the Mm_Models_ItemMapper
     *
     * @return Mm_Models_ItemMapper
     **/
    public function getItemMapper($newInstance = true)
    {
        if ($newInstance) {
            return new Mm_Model_ItemMapper();
        }
 
        if (null === $this->_itemMapper) {
            $this->setItemMapper(new Mm_Model_ItemMapper());
        }
        return $this->_itemMapper;
    }
 
    /**
     * Sets the Item Mapper instance to be used
     *
     * @return void
     **/
    public function setItemMapper($mapper)
    {
        $this->_itemMapper = $mapper;
    }
 
    /**
     * findOrder
     *
     * @param int $orderId
     * @return Mm_Model_Order|boolean
     */
    public function findOrder($orderId)
    {
        return $this->getOrderMapper()->find($orderId);
    }
 
    /**
     * findOrderTransactions
     *
     * @param Mm_Model_Order $order
     * @return array
     */
    public function findOrderTransactions($order)
    {
        return Doctrine_Query::create()
            ->select('trans.id, trans.description, trans.created,
                trans.transaction_type, transo.username, trans.minutes_worked,
                transo.id, transo.firstname, transo.lastname')
            ->from('dTransaction trans')
            ->leftJoin('trans.dUser transo')
            ->where('trans.ticket_id = ?', array($order->getId()))
            ->orderBy('trans.created DESC, trans.id ASC')
            ->execute();
    }
 
    /**
     * Creates a new Order
     *
     * @param   array   $options
     * @return  Mm_Model_Order
     **/
    public function createOrder($options)
    {
        $this->setOrderModelOptions($options['order']);
        $order = $this->getOrderModel();
        $this->setOrderModel($order);
 
        $mapper = $this->getOrderMapper(false);
        $mapper->loadCartFromArray($order, $options['cart']);
        $mapper->save($order);
        return $order;
    }
 
    /**
     * Updates an existing Order
     *
     * @return void
     **/
    public function updateOrder($options)
    {
        $listener = $this->loadDoctrineTransactionListener();
        if (isset($options['minutes_worked']) &&
            !empty($options['minutes_worked']))
        {
            $listener->setMinutesWorked($options['minutes_worked']);
        }
 
        $mapper = $this->getOrderMapper(false);
        $order = $mapper->find($options['id']);
        $order->import($options['order']);
        $mapper->loadCartFromArray($order, $options['cart']);
 
        $mapper->save($order);
 
        if (isset($options['transaction']) &&
            !empty($options['transaction']) &&
            is_array($options['transaction']))
        {
            $this->postWorkLogTransactionForOrder(
                $order->getId(), $options['transaction']
            );
        }
 
        if (isset($options['notifications']) &&
            !empty($options['notifications']) &&
            is_array($options['notifications']))
        {
            $this->notifyFlaggedRecipientsForOrder(
                $order->getId(), $options['notifications']
            );
        }
 
        return $order;
    }
 
    /**
     * Posts a transaction (work log entry) for the specified order
     *
     * @return void
     **/
    public function postWorkLogTransactionForOrder($orderId, $transactionOptions)
    {
        $transaction = new dTransaction();
        $transactionDetails = array(
            'ticket_id'        => $orderId,
            'user_id'          => dUser::currentUserId(),
            'transaction_type' => dTransaction::WORK_LOG,
            'owner_id'         => dUser::currentUserId(),
        );
        $transaction->merge($transactionOptions);
        $transaction->merge($transactionDetails);
        $transaction->save();
    }
 
    /**
     * undocumented function
     *
     * @return void
     **/
    public function notifyFlaggedRecipientsForOrder($orderId, $notificationOptions)
    {
        $mailer = new App_Notifications_Mailer($orderId);
        foreach ($notificationOptions as $name => $v) {
            if ($v) {
                $mailer->send(dNotification::NOTIFY_NAMED, $name);
            }
        }
    }
 
    /**
     * undocumented function
     *
     * @return void
     **/
    public function quickAssignOrderToUser($orderId, $userId)
    {
        $this->loadDoctrineTransactionListener();
        $this->getOrderMapper(false)->quickAssign($orderId, $userId);
    }
 
    public function fulltextSearch($term)
    {
        return $this->getItemMapper(false)->fulltextSearch($term);
    }
 
    /**
     * Finds the Mm_Model_Item by ID
     *
     * @return
     **/
    public function findItem($itemId)
    {
        return $this->getItemMapper(false)->find($itemId);
    }
 
    /**
     * Finds items related to the item specified by ID
     *
     * @return void
     **/
    public function findRelatedItems($itemId)
    {
        return $this->getItemMapper(false)->findRelated($itemId);
    }
 
    /**
     * undocumented function
     *
     * @return void
     **/
    public function findDuplicateOrderIds($orderOptions, $cart)
    {
        return $this->getOrderMapper(false)->getDuplicateOrderIds(
            $orderOptions,
            $cart
        );
    }
 
    /**
     * Finds all orders, paginated
     *
     * @return array
     **/
    public function findOrdersWithPagination($options)
    {
        $mapper = $this->getOrderMapper(false);
        /* These should probably be handled by the Mapper */
        if (! is_null($options['filters'])) {
            $mapper->setFilters($options['filters']);
        }
 
        if (! is_null($options['sort']['key']) ||
            ! is_null($options['sort']['order'])
        ) {
            $mapper->setSortOrder(
                $options['sort']['key'],
                $options['sort']['order']
            );
        }
        $mapper->setPage($options['page']);
        return $mapper->findAllWithPagination();
    }
 
    /**
     * Loads the transaction listener and returns
     *
     * @return App_TransactionListener
     */
    public function loadDoctrineTransactionListener()
    {
        $transactionListener = new App_TransactionListener();
        Doctrine_Manager::getInstance()->addListener($transactionListener);
        Doctrine_Manager::getInstance()->addRecordListener($transactionListener);
        return $transactionListener;
    }
}