if ($pointSaveConfig['percent'] > 0) {
            $basePoint = ($order->selling_price / 100) * $pointSaveConfig['percent'];
        }

        return $basePoint;
    }

    public function getGradeSavePoint(Order $order, Customer $customer = null)
    {
        // 비회원 지원 안함
        if ($customer == null && $order->user_id == false) {
            return 0;
        }

        if ($customer == null) {
            $customer = $this->customerService->getCustomerByUserId($order->user_id);
        }

        $gradePoint = '0';
        $rating = app('xehub_custom_develop.rating.handler')->getRating(auth()->user()->commerce_rating_rating_id);

        if ($rating && $rating->accumulate) {
            $gradePoint = ($order->selling_price / 100) * $rating->accumulate;
        }

//        if ($customer && $customer->customerGrade && $customer->customerGrade->benefit_commerce_point > 0) {
//            $gradePoint = ($order->price / 100) * $customer->customerGrade->benefit_commerce_point;
//        }

        return $gradePoint;
    }

    public function setCustomerPointToDraft(Order $order)
    {
        \Log::info('===> save point draft <<<<<---------');
        /**
         * 회원이 아니면 포인트 처리 안됨
         */
        if ($order->user_id == false) {
            return;

 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        /** @var AdvisorList $advisorList */
        $advisorList = $this->_getAdvisorCollection()->getAdvisorList(parent::class.'@'.$method);
 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        /** @var AdvisorList $advisorList */
        $advisorList = $this->_getAdvisorCollection()->getAdvisorList(parent::class.'@'.$method);
 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string
     */
    public function getTargetMethodName()
    {

    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string
     */
    public function getTargetMethodName()
    {

        intercept(
            OrderService::class . '@getConfigSavePoint',
            'xehub_custom_develop::getConfigSavePoint',
            static function ($method, Order $order, Customer $customer = null) {
                $configSavePoint = $method($order, $customer);
 
                if ($order->isGeneral()) {
                    $configSavePoint = 0;
                }
 
                return $configSavePoint;
            }
        );
 
        // 주문(order)에 대상에 따라 적립되는 등급(Grade) 포인트를 변경해줍니다.
        intercept(
            OrderService::class . '@getGradeSavePoint',
            'xehub_custom_develop::getGradeSavePoint',
            static function ($method, Order $order, Customer $customer = null) {
                $gradeSavePoint = $method($order, $customer);
 
                if ($order->isGeneral()) {
                    $gradeSavePoint = 0;
                }
 
                return $gradeSavePoint;
            }
        );
 
        // 주문 시 재고보다 더 많은 수를 주문할 수 없습니다.
        /** @TODO 11월 납품에는 재고 기능을 별도로 사용하지 않습니다. 임시로 주석 처리 */
//        intercept(
//            OrderService::class . '@newOrderItem',
//            'xehub_custom_develop::order::newOrderItem::outOfStock',
//            static function ($method, ProductOrderable $orderable, $quantity = 1, $shipping = 0, array $data = null) {
//                $product = $orderable->product;
//
//                if ($product && $product->is_manage_stock && $product->isGeneral() && $quantity > $product->stock_qty) {
//                    $exception = new HttpXpressengineException();
//                    $exception->setMessage('재고보다 더 많은 수를 주문할 수 없습니다.');

        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string

        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string

     */
    public function __construct($proxyObject, $methodName, AdvisorList $advisorList)
    {
        $this->proxyObject = $proxyObject;
        $this->targetMethodName = $methodName;
        $this->advisorList = $advisorList;
    }
 
    /**
     * target class의 origin method가 실행되기 전에 호출되어야 할 advisor를 호출한 다음, 마지막으로 origin method를 호출한다.
     *
     * @param array   $args 호출된 메소드가 받은 파라메터 리스트
     * @param Closure $then 호출된 메소드, advisor를 모두 호출한 후 이 Closure가 실행된다.
     *
     * @return mixed
     */
    public function callProxy(array $args, Closure $then)
    {
        $this->originMethodCall = $then;
        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {

     */
    public function __construct($proxyObject, $methodName, AdvisorList $advisorList)
    {
        $this->proxyObject = $proxyObject;
        $this->targetMethodName = $methodName;
        $this->advisorList = $advisorList;
    }
 
    /**
     * target class의 origin method가 실행되기 전에 호출되어야 할 advisor를 호출한 다음, 마지막으로 origin method를 호출한다.
     *
     * @param array   $args 호출된 메소드가 받은 파라메터 리스트
     * @param Closure $then 호출된 메소드, advisor를 모두 호출한 후 이 Closure가 실행된다.
     *
     * @return mixed
     */
    public function callProxy(array $args, Closure $then)
    {
        $this->originMethodCall = $then;
        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {

 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        return $ret;
    }
    public function updateToPaid(Xehub\XePlugin\XeCommerce\Order\OrderItem $item,  $force = false)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function getOrderSavePoint(Xehub\XePlugin\XeCommerce\Order\Order $order, Xehub\XePlugin\XeCommerce\Models\Customer $customer = NULL)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function getConfigSavePoint(Xehub\XePlugin\XeCommerce\Order\Order $order, Xehub\XePlugin\XeCommerce\Models\Customer $customer = NULL)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function getGradeSavePoint(Xehub\XePlugin\XeCommerce\Order\Order $order, Xehub\XePlugin\XeCommerce\Models\Customer $customer = NULL)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function setCustomerPointToDraft(Xehub\XePlugin\XeCommerce\Order\Order $order)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function setCustomerPoint(Xehub\XePlugin\XeCommerce\Order\Order $order)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function updateToStandby(Xehub\XePlugin\XeCommerce\Order\OrderItem $item,  $force = false)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function updateToShipping(Xehub\XePlugin\XeCommerce\Order\OrderItem $item,  $force = false)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);

//                    $order->id
//                );
//            }
//        }
    }

    public function setCustomerPoint(Order $order)
    {
        \Log::info('===> save point <<<<<---------');
        /**
         * 회원이 아니면 포인트 처리 안됨
         */
        if ($order->user_id == false) {
            return;
        }

        $basePoint = $this->getConfigSavePoint($order);
        $gradePoint = 0;
        if ($order->user()->isAdmin()) {
            $gradePoint = $this->getGradeSavePoint($order);
        }

        $totalPoint = $basePoint + $gradePoint;

        if ($totalPoint > 0) {
            $this->customerService->addCustomerPoint(
                $order->user_id,
                $totalPoint,
                'no-base',
                null,
                '구매 적립',
                '',
                'I',
                $order->id
            );
        }

//        if ($basePoint > 0) {
//            $this->customerService->addCustomerPoint(
//                $order->user_id,

 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        /** @var AdvisorList $advisorList */
        $advisorList = $this->_getAdvisorCollection()->getAdvisorList(parent::class.'@'.$method);
 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        /** @var AdvisorList $advisorList */
        $advisorList = $this->_getAdvisorCollection()->getAdvisorList(parent::class.'@'.$method);
 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string
     */
    public function getTargetMethodName()
    {

    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string
     */
    public function getTargetMethodName()
    {

            intercept(
                $intercept['target'],
                $intercept['name'],
                call_user_func($intercept['callback'])
            );
        }
    }
 
    /**
     * 인터셉트 1: 주문 결제 후 유저별 일일 결제 합계 기록
     * = 구매완료로 포인트 지급되는 시점에서 이달의 결제 금액, 건수 결제
     *
     * OrderService::setCustomerPoint 호출 후 실행됩니다.
     *
     * @return \Closure
     */
    public static function interceptOrderServiceSetCustomerPoint(): \Closure
    {
        return function ($func, $order = null) {
            $func($order);
 
            if (!$order || !$order->user || $order->selling_price <= 0) {
                return;
            }
 
            $date = date('Ymd');
 
            $userPaySum = UserPaySum::where('user_id', $order->user_id)
                ->where('pay_date', $date)
                ->first();
 
            if ($userPaySum) {
                $userPaySum->pay_sum += $order->selling_price;
                $userPaySum->pay_count += 1;
            } else {
                $userPaySum = new UserPaySum();
                $userPaySum->user_id = $order->user_id;
                $userPaySum->pay_date = $date;
                $userPaySum->pay_sum = $order->selling_price;
                $userPaySum->pay_count = 1;

        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string

        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string

     */
    public function __construct($proxyObject, $methodName, AdvisorList $advisorList)
    {
        $this->proxyObject = $proxyObject;
        $this->targetMethodName = $methodName;
        $this->advisorList = $advisorList;
    }
 
    /**
     * target class의 origin method가 실행되기 전에 호출되어야 할 advisor를 호출한 다음, 마지막으로 origin method를 호출한다.
     *
     * @param array   $args 호출된 메소드가 받은 파라메터 리스트
     * @param Closure $then 호출된 메소드, advisor를 모두 호출한 후 이 Closure가 실행된다.
     *
     * @return mixed
     */
    public function callProxy(array $args, Closure $then)
    {
        $this->originMethodCall = $then;
        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {

     */
    public function __construct($proxyObject, $methodName, AdvisorList $advisorList)
    {
        $this->proxyObject = $proxyObject;
        $this->targetMethodName = $methodName;
        $this->advisorList = $advisorList;
    }
 
    /**
     * target class의 origin method가 실행되기 전에 호출되어야 할 advisor를 호출한 다음, 마지막으로 origin method를 호출한다.
     *
     * @param array   $args 호출된 메소드가 받은 파라메터 리스트
     * @param Closure $then 호출된 메소드, advisor를 모두 호출한 후 이 Closure가 실행된다.
     *
     * @return mixed
     */
    public function callProxy(array $args, Closure $then)
    {
        $this->originMethodCall = $then;
        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {

 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        return $ret;
    }
    public function getConfigSavePoint(Xehub\XePlugin\XeCommerce\Order\Order $order, Xehub\XePlugin\XeCommerce\Models\Customer $customer = NULL)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function getGradeSavePoint(Xehub\XePlugin\XeCommerce\Order\Order $order, Xehub\XePlugin\XeCommerce\Models\Customer $customer = NULL)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function setCustomerPointToDraft(Xehub\XePlugin\XeCommerce\Order\Order $order)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function setCustomerPoint(Xehub\XePlugin\XeCommerce\Order\Order $order)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function updateToStandby(Xehub\XePlugin\XeCommerce\Order\OrderItem $item,  $force = false)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function updateToShipping(Xehub\XePlugin\XeCommerce\Order\OrderItem $item,  $force = false)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function updateToCompleted(Xehub\XePlugin\XeCommerce\Order\OrderItem $item)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function updateToTerminated(Xehub\XePlugin\XeCommerce\Order\OrderItem $item)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);

                    $this->updateToCompleted($item);
                }
            });
        });
    }

    /**
     * 자동 구매 확정 처리
     * 구매 완료 내역을 확정 처리 (주문을 정산 가능 형태로 변경)
     *
     * @param $startDate
     * @param $endDate
     */
    public function autoDecided($startDate, $endDate)
    {
        $orders = $this->getNotDecidedOrders(OrderItem::STATUS_COMPLETED, $startDate, $endDate);

        $orders->each(function ($order) {
            // 포인트 적립
            $this->setCustomerPoint($order);

            $order->items->each(function ($item) {
                // 취소요청 중이거나 취소완료 상태면 구매확정 처리하지 않음
                if ($item->cancellation) {
                    if ($item->cancellation->statusIsRequest() || $item->cancellation->statusIsApprove()) {
                        return;
                    }
                }
                $this->updateToDecide($item);
            });

            $this->customerService->updateCustomerOrder($order);
        });
    }

    /**
     * 단일 상품 구매
     *
     * @param $productId
     * @param $quantity

     * Get the items in the collection whose keys are not present in the given items.
     *
     * @param  mixed  $items
     * @return static
     */
    public function diffKeys($items)
    {
        return new static(array_diff_key($this->items, $this->getArrayableItems($items)));
    }
 
    /**
     * Execute a callback over each item.
     *
     * @param  callable  $callback
     * @return $this
     */
    public function each(callable $callback)
    {
        foreach ($this->items as $key => $item) {
            if ($callback($item, $key) === false) {
                break;
            }
        }
 
        return $this;
    }
 
    /**
     * Execute a callback over each nested chunk of items.
     *
     * @param  callable  $callback
     * @return static
     */
    public function eachSpread(callable $callback)
    {
        return $this->each(function ($chunk, $key) use ($callback) {
            $chunk[] = $key;
 
            return $callback(...$chunk);
        });

    public function autoDecided($startDate, $endDate)
    {
        $orders = $this->getNotDecidedOrders(OrderItem::STATUS_COMPLETED, $startDate, $endDate);

        $orders->each(function ($order) {
            // 포인트 적립
            $this->setCustomerPoint($order);

            $order->items->each(function ($item) {
                // 취소요청 중이거나 취소완료 상태면 구매확정 처리하지 않음
                if ($item->cancellation) {
                    if ($item->cancellation->statusIsRequest() || $item->cancellation->statusIsApprove()) {
                        return;
                    }
                }
                $this->updateToDecide($item);
            });

            $this->customerService->updateCustomerOrder($order);
        });
    }

    /**
     * 단일 상품 구매
     *
     * @param $productId
     * @param $quantity
     * @param  UserInterface|null  $user
     * @return Order
     * @throws \Throwable
     */
    public function createOrderSimple($productId, $quantity, UserInterface $user = null)
    {
        \XeDB::beginTransaction();
        try {
            $product = \Xehub\XePlugin\XeCommerce\Product\Product::with([
                'ship',
                'options.attrs.vals',
                'options.units' => function ($query) {
                    $query->with('attrVals')->hidden(false);

 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        /** @var AdvisorList $advisorList */
        $advisorList = $this->_getAdvisorCollection()->getAdvisorList(parent::class.'@'.$method);
 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        /** @var AdvisorList $advisorList */
        $advisorList = $this->_getAdvisorCollection()->getAdvisorList(parent::class.'@'.$method);
 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string
     */
    public function getTargetMethodName()
    {

    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {
            $closure = $this->originMethodCall;
            return call_user_func_array($closure, $args);
        }
    }
 
    /**
     * target object(proxy object)를 반환한다.
     *
     * @return Object
     */
    public function getTargetObject()
    {
        return $this->proxyObject;
    }
 
    /**
     * 호출된 메소드명을 반환한다.
     *
     * @return string
     */
    public function getTargetMethodName()
    {

     */
    public function __construct($proxyObject, $methodName, AdvisorList $advisorList)
    {
        $this->proxyObject = $proxyObject;
        $this->targetMethodName = $methodName;
        $this->advisorList = $advisorList;
    }
 
    /**
     * target class의 origin method가 실행되기 전에 호출되어야 할 advisor를 호출한 다음, 마지막으로 origin method를 호출한다.
     *
     * @param array   $args 호출된 메소드가 받은 파라메터 리스트
     * @param Closure $then 호출된 메소드, advisor를 모두 호출한 후 이 Closure가 실행된다.
     *
     * @return mixed
     */
    public function callProxy(array $args, Closure $then)
    {
        $this->originMethodCall = $then;
        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {

     */
    public function __construct($proxyObject, $methodName, AdvisorList $advisorList)
    {
        $this->proxyObject = $proxyObject;
        $this->targetMethodName = $methodName;
        $this->advisorList = $advisorList;
    }
 
    /**
     * target class의 origin method가 실행되기 전에 호출되어야 할 advisor를 호출한 다음, 마지막으로 origin method를 호출한다.
     *
     * @param array   $args 호출된 메소드가 받은 파라메터 리스트
     * @param Closure $then 호출된 메소드, advisor를 모두 호출한 후 이 Closure가 실행된다.
     *
     * @return mixed
     */
    public function callProxy(array $args, Closure $then)
    {
        $this->originMethodCall = $then;
        return call_user_func_array($this, $args);
    }
 
    /**
     * proxy object의 메소드가 실행될 경우, 메소드에 지정된 advisor를 모두 실행시킨다.
     * 이때 decorator 패턴으로 advisor들이 실행되는데,
     * 각 advisor들이 next call을 할 때 proxy는 자기 자신을 호출하도록 하여 결국 이 메소드가 실행된다.
     * 이 메소드가 호출되면 다음 advisor를 찾아서 실행시켜주고, 더이상 실행할 advisor가 없을 경우 원래 호출된 proxy object의 메소드를 실행한다.
     *
     * @return mixed
     */
    public function __invoke()
    {
        $args = func_get_args();
        $advisor = $this->advisorList->next();
 
        if ($advisor) {
            $advice = $advisor->getAdvice();
            $argsWithThis = array_merge([$this], $args);
            return call_user_func_array($advice, $argsWithThis);
        } else {

 
        $invocationHandler = new ProxyInvocationHandler($this, $method, $advisorList);
 
        // 등록된 advisor들을 호출한다. advisor들이 실행되고 마지막으로 called method를 실행한다.
        return $invocationHandler->callProxy(
            $arguments,
            // 등록된 advisor들이 모두 호출된 다음 마지막에 호출되어 target의 origin method를 실행하는 클로저
            function () use ($method, $isCallMagicMethod) {
                $args = func_get_args();
 
                if ($isCallMagicMethod) {
                    array_unshift($args, $method);
                    $method = '__call';
                }
 
                return call_user_func_array(
                    [$this, '_proxyTargetCall'],
                    [$method, $args]
                );
            }
        );
    }
 
    /**
     * 본래 실행하려고 했던 실제 타겟 오브젝트의 메소드를 실행한다.
     *
     * @param string $method    origin method
     * @param array  $arguments argument of method call
     *
     * @return mixed
     */
    private function _proxyTargetCall($method, $arguments)
    {
        return call_user_func_array("parent::$method", $arguments);
    }
}
 

        return $ret;
    }
    public function buildItems( $items)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function cleanUp()    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function intangibleToAutoCompleted( $startDate,  $endDate)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function autoDecided( $startDate,  $endDate)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function createOrderSimple( $productId,  $quantity, Xpressengine\User\UserInterface $user = NULL)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function getPaymentMethod( $order = NULL)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function filterPaymentMethod(Xehub\XePlugin\XeCommerce\Product\Product $product,  $paymentMethodList)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);
        return $ret;
    }
    public function getPaymentHtmlScript(Xehub\XePlugin\XeCommerce\Order\Order $order)    {
        $argv = func_get_args();
        $ret = $this->_proxyMethodCall(__FUNCTION__, $argv);

        $this->orderService->setCleanupCache();

        // 장바구니 정리 (오래된 항목 제거)
        $this->cartService->cleanUp();
        // 주문 revoke
        $this->orderService->cleanUp();

        if ($config = app('xe.config')->get(\Xehub\XePlugin\XeCommerce\Plugin::getId())) {
            // 배송타입 없는 주문 결제완료 시 N일 후 배송완료 처리
            if ($config->get('enable_intangible_completed', false)) {
                $endDate = now()->subDays($config->get('completed_period', 3));
                $startDate = $endDate->copy()->subDays($config->get('intangible_completed_cleanup_range', 3));
                $this->orderService->intangibleToAutoCompleted($startDate, $endDate);
            }

            // 배송완료 주문 N일 후 구매확정 처리
            if ($config->get('enable_decide', false)) {
                $endDate = now()->subDays($config->get('decide_period', 7));
                $startDate = $endDate->copy()->subDays($config->get('decide_cleanup_range', 3));
                $this->orderService->autoDecided($startDate, $endDate);
            }
        }
    }
}
 

class BoundMethod
{
    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return call_user_func_array(
                $callback, static::getMethodDependencies($container, $callback, $parameters)
            );
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method

class BoundMethod
{
    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return call_user_func_array(
                $callback, static::getMethodDependencies($container, $callback, $parameters)
            );
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method

     * @param  callable  $callback
     * @param  mixed  $default
     * @return mixed
     */
    protected static function callBoundMethod($container, $callback, $default)
    {
        if (! is_array($callback)) {
            return $default instanceof Closure ? $default() : $default;
        }
 
        // Here we need to turn the array callable into a Class@method string we can use to
        // examine the container and see if there are any method bindings for this given
        // method. If there are, we can call this method binding callback immediately.
        $method = static::normalizeMethod($callback);
 
        if ($container->hasMethodBinding($method)) {
            return $container->callMethodBinding($method, $callback[0]);
        }
 
        return $default instanceof Closure ? $default() : $default;
    }
 
    /**
     * Normalize the given callback into a Class@method string.
     *
     * @param  callable  $callback
     * @return string
     */
    protected static function normalizeMethod($callback)
    {
        $class = is_string($callback[0]) ? $callback[0] : get_class($callback[0]);
 
        return "{$class}@{$callback[1]}";
    }
 
    /**
     * Get all dependencies for a given method.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback

    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return call_user_func_array(
                $callback, static::getMethodDependencies($container, $callback, $parameters)
            );
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method
        // name. We will split on this @ sign and then build a callable array that
        // we can pass right back into the "call" method for dependency binding.

     * @return \Closure
     */
    public function wrap(Closure $callback, array $parameters = [])
    {
        return function () use ($callback, $parameters) {
            return $this->call($callback, $parameters);
        };
    }
 
    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public function call($callback, array $parameters = [], $defaultMethod = null)
    {
        return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
    }
 
    /**
     * Get a closure to resolve the given type from the container.
     *
     * @param  string  $abstract
     * @return \Closure
     */
    public function factory($abstract)
    {
        return function () use ($abstract) {
            return $this->make($abstract);
        };
    }
 
    /**
     * An alias function name for make().
     *
     * @param  string  $abstract
     * @param  array  $parameters

     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return int
     */
    public function run(InputInterface $input, OutputInterface $output)
    {
        return parent::run(
            $this->input = $input, $this->output = new OutputStyle($input, $output)
        );
    }
 
    /**
     * Execute the console command.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return mixed
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        return $this->laravel->call([$this, 'handle']);
    }
 
    /**
     * Call another console command.
     *
     * @param  string  $command
     * @param  array   $arguments
     * @return int
     */
    public function call($command, array $arguments = [])
    {
        $arguments['command'] = $command;
 
        return $this->getApplication()->find($command)->run(
            $this->createInputFromArguments($arguments), $this->output
        );
    }
 
    /**
     * Call another console command silently.

            }
        }
 
        if ($input->isInteractive()) {
            $this->interact($input, $output);
        }
 
        // The command name argument is often omitted when a command is executed directly with its run() method.
        // It would fail the validation if we didn't make sure the command argument is present,
        // since it's required by the application.
        if ($input->hasArgument('command') && null === $input->getArgument('command')) {
            $input->setArgument('command', $this->getName());
        }
 
        $input->validate();
 
        if ($this->code) {
            $statusCode = \call_user_func($this->code, $input, $output);
        } else {
            $statusCode = $this->execute($input, $output);
        }
 
        return is_numeric($statusCode) ? (int) $statusCode : 0;
    }
 
    /**
     * Sets the code to execute when running this command.
     *
     * If this method is used, it overrides the code defined
     * in the execute() method.
     *
     * @param callable $code A callable(InputInterface $input, OutputInterface $output)
     *
     * @return $this
     *
     * @throws InvalidArgumentException
     *
     * @see execute()
     */
    public function setCode(callable $code)

        foreach ($this->getArguments() as $arguments) {
            call_user_func_array([$this, 'addArgument'], $arguments);
        }
 
        foreach ($this->getOptions() as $options) {
            call_user_func_array([$this, 'addOption'], $options);
        }
    }
 
    /**
     * Run the console command.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return int
     */
    public function run(InputInterface $input, OutputInterface $output)
    {
        return parent::run(
            $this->input = $input, $this->output = new OutputStyle($input, $output)
        );
    }
 
    /**
     * Execute the console command.
     *
     * @param  \Symfony\Component\Console\Input\InputInterface  $input
     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
     * @return mixed
     */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        return $this->laravel->call([$this, 'handle']);
    }
 
    /**
     * Call another console command.
     *
     * @param  string  $command
     * @param  array   $arguments

    }
 
    /**
     * Runs the current command.
     *
     * If an event dispatcher has been attached to the application,
     * events are also dispatched during the life-cycle of the command.
     *
     * @return int 0 if everything went fine, or an error code
     */
    protected function doRunCommand(Command $command, InputInterface $input, OutputInterface $output)
    {
        foreach ($command->getHelperSet() as $helper) {
            if ($helper instanceof InputAwareInterface) {
                $helper->setInput($input);
            }
        }
 
        if (null === $this->dispatcher) {
            return $command->run($input, $output);
        }
 
        // bind before the console.command event, so the listeners have access to input options/arguments
        try {
            $command->mergeApplicationDefinition();
            $input->bind($command->getDefinition());
        } catch (ExceptionInterface $e) {
            // ignore invalid options/arguments for now, to allow the event listeners to customize the InputDefinition
        }
 
        $event = new ConsoleCommandEvent($command, $input, $output);
        $e = null;
 
        try {
            $this->dispatcher->dispatch(ConsoleEvents::COMMAND, $event);
 
            if ($event->commandShouldRun()) {
                $exitCode = $command->run($input, $output);
            } else {
                $exitCode = ConsoleCommandEvent::RETURN_CODE_DISABLED;

            $command = $this->find($name);
        } catch (\Exception $e) {
        } catch (\Throwable $e) {
        }
        if (null !== $e) {
            if (null !== $this->dispatcher) {
                $event = new ConsoleErrorEvent($input, $output, $e);
                $this->dispatcher->dispatch(ConsoleEvents::ERROR, $event);
                $e = $event->getError();
 
                if (0 === $event->getExitCode()) {
                    return 0;
                }
            }
 
            throw $e;
        }
 
        $this->runningCommand = $command;
        $exitCode = $this->doRunCommand($command, $input, $output);
        $this->runningCommand = null;
 
        return $exitCode;
    }
 
    public function setHelperSet(HelperSet $helperSet)
    {
        $this->helperSet = $helperSet;
    }
 
    /**
     * Get the helper set associated with the command.
     *
     * @return HelperSet The HelperSet instance associated with this command
     */
    public function getHelperSet()
    {
        if (!$this->helperSet) {
            $this->helperSet = $this->getDefaultHelperSet();
        }

                $this->renderException($e, $output);
            }
        };
        if ($phpHandler = set_exception_handler($renderException)) {
            restore_exception_handler();
            if (!\is_array($phpHandler) || !$phpHandler[0] instanceof ErrorHandler) {
                $debugHandler = true;
            } elseif ($debugHandler = $phpHandler[0]->setExceptionHandler($renderException)) {
                $phpHandler[0]->setExceptionHandler($debugHandler);
            }
        }
 
        if (null !== $this->dispatcher && $this->dispatcher->hasListeners(ConsoleEvents::EXCEPTION)) {
            @trigger_error(sprintf('The "ConsoleEvents::EXCEPTION" event is deprecated since Symfony 3.3 and will be removed in 4.0. Listen to the "ConsoleEvents::ERROR" event instead.'), \E_USER_DEPRECATED);
        }
 
        $this->configureIO($input, $output);
 
        try {
            $exitCode = $this->doRun($input, $output);
        } catch (\Exception $e) {
            if (!$this->catchExceptions) {
                throw $e;
            }
 
            $renderException($e);
 
            $exitCode = $e->getCode();
            if (is_numeric($exitCode)) {
                $exitCode = (int) $exitCode;
                if (0 === $exitCode) {
                    $exitCode = 1;
                }
            } else {
                $exitCode = 1;
            }
        } finally {
            // if the exception handler changed, keep it
            // otherwise, unregister $renderException
            if (!$phpHandler) {

 
        $this->bootstrap();
    }
 
    /**
     * {@inheritdoc}
     */
    public function run(InputInterface $input = null, OutputInterface $output = null)
    {
        $commandName = $this->getCommandName(
            $input = $input ?: new ArgvInput
        );
 
        $this->events->fire(
            new Events\CommandStarting(
                $commandName, $input, $output = $output ?: new ConsoleOutput
            )
        );
 
        $exitCode = parent::run($input, $output);
 
        $this->events->fire(
            new Events\CommandFinished($commandName, $input, $output, $exitCode)
        );
 
        return $exitCode;
    }
 
    /**
     * Determine the proper PHP executable.
     *
     * @return string
     */
    public static function phpBinary()
    {
        return ProcessUtils::escapeArgument((new PhpExecutableFinder)->find(false));
    }
 
    /**
     * Determine the proper Artisan executable.

        static::$bootstrappers = [];
    }
 
    /**
     * Run an Artisan console command by name.
     *
     * @param  string  $command
     * @param  array  $parameters
     * @param  \Symfony\Component\Console\Output\OutputInterface  $outputBuffer
     * @return int
     */
    public function call($command, array $parameters = [], $outputBuffer = null)
    {
        $parameters = collect($parameters)->prepend($command);
 
        $this->lastOutput = $outputBuffer ?: new BufferedOutput;
 
        $this->setCatchExceptions(false);
 
        $result = $this->run(new ArrayInput($parameters->toArray()), $this->lastOutput);
 
        $this->setCatchExceptions(true);
 
        return $result;
    }
 
    /**
     * Get the output for the last run command.
     *
     * @return string
     */
    public function output()
    {
        return $this->lastOutput ? $this->lastOutput->fetch() : '';
    }
 
    /**
     * Add a command to the console.
     *
     * @param  \Symfony\Component\Console\Command\Command  $command

     * @return void
     */
    public function registerCommand($command)
    {
        $this->getArtisan()->add($command);
    }
 
    /**
     * Run an Artisan console command by name.
     *
     * @param  string  $command
     * @param  array  $parameters
     * @param  \Symfony\Component\Console\Output\OutputInterface  $outputBuffer
     * @return int
     */
    public function call($command, array $parameters = [], $outputBuffer = null)
    {
        $this->bootstrap();
 
        return $this->getArtisan()->call($command, $parameters, $outputBuffer);
    }
 
    /**
     * Queue the given console command.
     *
     * @param  string  $command
     * @param  array   $parameters
     * @return \Illuminate\Foundation\Bus\PendingDispatch
     */
    public function queue($command, array $parameters = [])
    {
        return QueuedCommand::dispatch(func_get_args());
    }
 
    /**
     * Get all of the commands registered with the console.
     *
     * @return array
     */
    public function all()

    }
 
    /**
     * Handle dynamic, static calls to the object.
     *
     * @param  string  $method
     * @param  array   $args
     * @return mixed
     *
     * @throws \RuntimeException
     */
    public static function __callStatic($method, $args)
    {
        $instance = static::getFacadeRoot();
 
        if (! $instance) {
            throw new RuntimeException('A facade root has not been set.');
        }
 
        return $instance->$method(...$args);
    }
}
 

        app(ConfigHandler::class)->text('paywill', [
            'id' => '상점아이디',
            'key' => '해시키',
        ], '페이윌');
 
        app()->terminating(function () {
            // ajax 폴링으로 인해 해당 로직이 중복 실행되는 걸 방지합니다. (2025.03.19)
            if (filled($request = request())) {
                if ($request->ajax() || $request->wantsJson()) {
                    return;
                }
            }
 
            // html response 에만 동작하도록 개선 필요
            $orderService = app(OrderService::class);
            $proc = $orderService->checkRunCleanupCache();
 
            // $checkMinute 분 경과 후 api 찌르기
            if ($proc) {
                \Illuminate\Support\Facades\Artisan::call('xecommerce:cleanup');
            }
        });
 
        LectureTypeHandler::boot();
        PackageTypeHandler::boot();
        BillingTypeHandler::boot();
        CounselTypeHandler::boot();
        LectureUser::bootMacro();
        LecturePosterHandler::boot();
 
        SellerInstructor::boot();
 
        Product::setPermalinkResolver(function ($product) {
            try {
                return route('xecommerce::product.show', $product->id);
            } catch (\Throwable $e) {
                return '#';
            }
        });
 

class BoundMethod
{
    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return call_user_func_array(
                $callback, static::getMethodDependencies($container, $callback, $parameters)
            );
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method

class BoundMethod
{
    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return call_user_func_array(
                $callback, static::getMethodDependencies($container, $callback, $parameters)
            );
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method

            throw new InvalidArgumentException('Method not provided.');
        }
 
        return static::call(
            $container, [$container->make($segments[0]), $method], $parameters
        );
    }
 
    /**
     * Call a method that has been bound to the container.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable  $callback
     * @param  mixed  $default
     * @return mixed
     */
    protected static function callBoundMethod($container, $callback, $default)
    {
        if (! is_array($callback)) {
            return $default instanceof Closure ? $default() : $default;
        }
 
        // Here we need to turn the array callable into a Class@method string we can use to
        // examine the container and see if there are any method bindings for this given
        // method. If there are, we can call this method binding callback immediately.
        $method = static::normalizeMethod($callback);
 
        if ($container->hasMethodBinding($method)) {
            return $container->callMethodBinding($method, $callback[0]);
        }
 
        return $default instanceof Closure ? $default() : $default;
    }
 
    /**
     * Normalize the given callback into a Class@method string.
     *
     * @param  callable  $callback
     * @return string
     */

    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
    {
        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
            return static::callClass($container, $callback, $parameters, $defaultMethod);
        }
 
        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
            return call_user_func_array(
                $callback, static::getMethodDependencies($container, $callback, $parameters)
            );
        });
    }
 
    /**
     * Call a string reference to a class using Class@method syntax.
     *
     * @param  \Illuminate\Container\Container  $container
     * @param  string  $target
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
    {
        $segments = explode('@', $target);
 
        // We will assume an @ sign is used to delimit the class name from the method
        // name. We will split on this @ sign and then build a callable array that
        // we can pass right back into the "call" method for dependency binding.

     * @return \Closure
     */
    public function wrap(Closure $callback, array $parameters = [])
    {
        return function () use ($callback, $parameters) {
            return $this->call($callback, $parameters);
        };
    }
 
    /**
     * Call the given Closure / class@method and inject its dependencies.
     *
     * @param  callable|string  $callback
     * @param  array  $parameters
     * @param  string|null  $defaultMethod
     * @return mixed
     */
    public function call($callback, array $parameters = [], $defaultMethod = null)
    {
        return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
    }
 
    /**
     * Get a closure to resolve the given type from the container.
     *
     * @param  string  $abstract
     * @return \Closure
     */
    public function factory($abstract)
    {
        return function () use ($abstract) {
            return $this->make($abstract);
        };
    }
 
    /**
     * An alias function name for make().
     *
     * @param  string  $abstract
     * @param  array  $parameters

     *
     * @param  \Closure  $callback
     * @return $this
     */
    public function terminating(Closure $callback)
    {
        $this->terminatingCallbacks[] = $callback;
 
        return $this;
    }
 
    /**
     * Terminate the application.
     *
     * @return void
     */
    public function terminate()
    {
        foreach ($this->terminatingCallbacks as $terminating) {
            $this->call($terminating);
        }
    }
 
    /**
     * Get the service providers that have been loaded.
     *
     * @return array
     */
    public function getLoadedProviders()
    {
        return $this->loadedProviders;
    }
 
    /**
     * Get the application's deferred services.
     *
     * @return array
     */
    public function getDeferredServices()
    {

    {
        return function ($request) {
            $this->app->instance('request', $request);
 
            return $this->router->dispatch($request);
        };
    }
 
    /**
     * Call the terminate method on any terminable middleware.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Http\Response  $response
     * @return void
     */
    public function terminate($request, $response)
    {
        $this->terminateMiddleware($request, $response);
 
        $this->app->terminate();
    }
 
    /**
     * Call the terminate method on any terminable middleware.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Illuminate\Http\Response  $response
     * @return void
     */
    protected function terminateMiddleware($request, $response)
    {
        $middlewares = $this->app->shouldSkipMiddleware() ? [] : array_merge(
            $this->gatherRouteMiddleware($request),
            $this->middleware
        );
 
        foreach ($middlewares as $middleware) {
            if (! is_string($middleware)) {
                continue;
            }

*/
 
/*if (!empty(array_get($_GET, '_construction')) || !isset($_SERVER['REMOTE_ADDR']) || !in_array($_SERVER['REMOTE_ADDR'], [
    '127.0.0.1',        // localhost
    '112.219.118.6',    // xehub
    '39.115.162.14',    // osh private
])) {
include('./construction.html');
exit();
}*/
 
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
 
$response = $kernel->handle(
    $request = Xpressengine\Http\Request::capture()
);
 
$response->send();
 
$kernel->terminate($request, $response);