• Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Register
  • Login
Bagisto Forum

Bagisto

  • Register
  • Login
  • Search
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups

Override Repository

General Discussion
3
3
340
Loading More Posts
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • F
    fab5freddy last edited by 9 Dec 2021, 15:33

    What is the correct way to override a repository in Bagisto. I'm trying to add additional function to the ProductFlatRepository. I know how to override a model correctly but I keep getting an error when trying to override a repository about a missing Proxy class.

    This is the code I currently have in the boot method of my serviceProvider in my custom package

    $this->app->concord->registerModel(
                \Webkul\Product\Repositories\ProductFlatRepository::class, \Particular\Product\Repositories\ProductFlatRepository::class
            );
    

    This is the error message I'm seeing.

    Class 'Webkul\Product\Models\ProductFlatRepositoryProxy' not found
    
    1 Reply Last reply Reply Quote 0
    • devansh-webkul
      devansh-webkul last edited by 13 Dec 2021, 03:56

      Hi @fab5freddy,

      The error clearly simple you forget to create the ProductFlatRepositoryProxy or something not registered in the module service provider.

      Please check once again.

      1 Reply Last reply Reply Quote 0
      • 2 years later
      • R
        Rimeri 0 last edited by 4 Feb 2024, 17:16

        Hi all,

        <?php

        namespace Webkul\Sales\Repositories;

        use Illuminate\Container\Container;
        use Illuminate\Support\Facades\DB;
        use Illuminate\Support\Facades\Event;
        use Illuminate\Support\Facades\Log;
        use Webkul\Core\Eloquent\Repository;
        use Webkul\Sales\Generators\OrderSequencer;
        use Webkul\Sales\Models\Order as OrderModel;

        class OrderRepository extends Repository
        {
        /**
        * @var OrderItemRepository
        */
        protected OrderItemRepository $orderItemRepository;

        /**
         * @var DownloadableLinkPurchasedRepository
         */
        protected DownloadableLinkPurchasedRepository $downloadableLinkPurchasedRepository;
        
        /**
         * @var InvoiceRepository
         */
        protected InvoiceRepository $invoiceRepository;
        
        /**
         * Create a new repository instance.
         *
         * @param  OrderItemRepository  $orderItemRepository
         * @param  DownloadableLinkPurchasedRepository  $downloadableLinkPurchasedRepository
         * @param  InvoiceRepository  $invoiceRepository
         * @param  Container  $container
         * @return void
         */
        public function __construct(
            OrderItemRepository $orderItemRepository,
            DownloadableLinkPurchasedRepository $downloadableLinkPurchasedRepository,
            InvoiceRepository $invoiceRepository,
            Container $container
        )
        {
            parent::__construct($container);
        
            $this->orderItemRepository = $orderItemRepository;
            $this->downloadableLinkPurchasedRepository = $downloadableLinkPurchasedRepository;
            $this->invoiceRepository = $invoiceRepository;
        }
        
        /**
         * Specify model class name.
         *
         * @return string
         */
        public function model(): string
        {
            return 'Webkul\Sales\Contracts\Order';
        }
        
        /**
         * This method will try attempt to a create order.
         *
         * @return \Webkul\Sales\Contracts\Order
         */
        public function createOrderIfNotThenRetry(array $data)
        {
            DB::beginTransaction();
        
            try {
                Event::dispatch('checkout.order.save.before', [$data]);
        
                if (! empty($data['customer'])) {
                    $data['customer_id'] = $data['customer']->id;
                    $data['customer_type'] = get_class($data['customer']);
                } else {
                    unset($data['customer']);
                }
        
                if (! empty($data['channel'])) {
                    $data['channel_id'] = $data['channel']->id;
                    $data['channel_type'] = get_class($data['channel']);
                    $data['channel_name'] = $data['channel']->name;
                } else {
                    unset($data['channel']);
                }
        
                $data['status'] = 'pending';
        
                $order = $this->model->create(array_merge($data, ['increment_id' => $this->generateIncrementId()]));
        
                $order->payment()->create($data['payment']);
        
                if (isset($data['shipping_address'])) {
                    unset($data['shipping_address']['customer_id']);
        
                    $order->addresses()->create($data['shipping_address']);
                }
        
                unset($data['billing_address']['customer_id']);
        
                $order->addresses()->create($data['billing_address']);
        
                foreach ($data['items'] as $item) {
                    Event::dispatch('checkout.order.orderitem.save.before', $item);
        
                    $orderItem = $this->orderItemRepository->create(array_merge($item, ['order_id' => $order->id]));
        
                    if (! empty($item['children'])) {
                        foreach ($item['children'] as $child) {
                            $this->orderItemRepository->create(array_merge($child, ['order_id' => $order->id, 'parent_id' => $orderItem->id]));
                        }
                    }
        
                    $this->orderItemRepository->manageInventory($orderItem);
        
                    $this->downloadableLinkPurchasedRepository->saveLinks($orderItem, 'available');
        
                    Event::dispatch('checkout.order.orderitem.save.after', $orderItem);
                }
        
                Event::dispatch('checkout.order.save.after', $order);
            } catch (\Exception $e) {
                /* rolling back first */
                DB::rollBack();
        
                /* storing log for errors */
                Log::error(
                    'OrderRepository:createOrderIfNotThenRetry: ' . $e->getMessage(),
                    ['data' => $data]
                );
        
                /* recalling */
                $this->createOrderIfNotThenRetry($data);
            } finally {
                /* commit in each case */
                DB::commit();
            }
        
            return $order;
        }
        
        /**
         * Create order.
         *
         * @param  array  $data
         * @return \Webkul\Sales\Contracts\Order
         */
        public function create(array $data)
        {
            return $this->createOrderIfNotThenRetry($data);
        }
        
        /**
         * Cancel order. This method should be independent as admin also can cancel the order.
         *
         * @param  \Webkul\Sales\Models\Order|int  $orderOrId
         * @return \Webkul\Sales\Contracts\Order
         */
        public function cancel($orderOrId)
        {
            /* order */
            $order = $this->resolveOrderInstance($orderOrId);
        
            /* check wether order can be cancelled or not */
            if (! $order->canCancel()) {
                return false;
            }
        
            Event::dispatch('sales.order.cancel.before', $order);
        
            foreach ($order->items as $item) {
                if (! $item->qty_to_cancel) {
                    continue;
                }
        
                $orderItems = [];
        
                if ($item->getTypeInstance()->isComposite()) {
                    foreach ($item->children as $child) {
                        $orderItems[] = $child;
                    }
                } else {
                    $orderItems[] = $item;
                }
        
                foreach ($orderItems as $orderItem) {
                    $this->orderItemRepository->returnQtyToProductInventory($orderItem);
        
                    if ($orderItem->qty_ordered) {
                        $orderItem->qty_canceled += $orderItem->qty_to_cancel;
                        $orderItem->save();
        
                        if (
                            $orderItem->parent
                            && $orderItem->parent->qty_ordered
                        ) {
                            $orderItem->parent->qty_canceled += $orderItem->parent->qty_to_cancel;
                            $orderItem->parent->save();
                        }
                    } else {
                        $orderItem->parent->qty_canceled += $orderItem->parent->qty_to_cancel;
                        $orderItem->parent->save();
                    }
                }
        
                $this->downloadableLinkPurchasedRepository->updateStatus($item, 'expired');
            }
        
            $this->updateOrderStatus($order);
        
            Event::dispatch('sales.order.cancel.after', $order);
        
            return true;
        }
        
        /**
         * Generate increment id.
         *
         * @return int
         */
        public function generateIncrementId()
        {
            return app(OrderSequencer::class)->resolveGeneratorClass();
        }
        
        /**
         * Is order in completed state.
         *
         * @param  \Webkul\Sales\Contracts\Order  $order
         * @return void
         */
        public function isInCompletedState($order)
        {
            $totalQtyOrdered = $totalQtyInvoiced = $totalQtyShipped = $totalQtyRefunded = $totalQtyCanceled = 0;
        
            foreach ($order->items()->get() as $item) {
                $totalQtyOrdered += $item->qty_ordered;
                $totalQtyInvoiced += $item->qty_invoiced;
        
                if (! $item->isStockable()) {
                    $totalQtyShipped += $item->qty_invoiced;
                } else {
                    $totalQtyShipped += $item->qty_shipped;
                }
        
                $totalQtyRefunded += $item->qty_refunded;
                $totalQtyCanceled += $item->qty_canceled;
            }
        
            if (
                $totalQtyOrdered != ($totalQtyRefunded + $totalQtyCanceled)
                && $totalQtyOrdered == $totalQtyInvoiced + $totalQtyCanceled
                && $totalQtyOrdered == $totalQtyShipped + $totalQtyRefunded + $totalQtyCanceled
            ) {
                return true;
            }
        
            /**
             * If order is already completed and total quantity ordered is not equal to refunded
             * then it can be considered as completed.
             */
            if (
                $order->status === OrderModel::STATUS_COMPLETED
                && $totalQtyOrdered != $totalQtyRefunded
            ) {
                return true;
            }
        
            return false;
        }
        
        /**
         * Is order in cancelled state.
         *
         * @param  \Webkul\Sales\Contracts\Order  $order
         * @return void
         */
        public function isInCanceledState($order)
        {
            $totalQtyOrdered = $totalQtyCanceled = 0;
        
            foreach ($order->items()->get() as $item) {
                $totalQtyOrdered += $item->qty_ordered;
                $totalQtyCanceled += $item->qty_canceled;
            }
        
            return $totalQtyOrdered === $totalQtyCanceled;
        }
        
        /**
         * Is order in closed state.
         *
         * @param mixed $order
         * @return void
         */
        public function isInClosedState($order)
        {
            $totalQtyOrdered = $totalQtyRefunded = $totalQtyCanceled = 0;
        
            foreach ($order->items()->get() as $item) {
                $totalQtyOrdered += $item->qty_ordered;
                $totalQtyRefunded += $item->qty_refunded;
                $totalQtyCanceled += $item->qty_canceled;
            }
        
            return $totalQtyOrdered === $totalQtyRefunded + $totalQtyCanceled;
        }
        
        /**
         * Update order status.
         *
         * @param  \Webkul\Sales\Contracts\Order  $order
         * @param  string $orderState
         * @return void
         */
        public function updateOrderStatus($order, $orderState = null)
        {
            Event::dispatch('sales.order.update-status.before', $order);
        
            if (! empty($orderState)) {
                $status = $orderState;
            } else {
                $status = "processing";
        
                if ($this->isInCompletedState($order)) {
                    $status = 'completed';
                }
        
                if ($this->isInCanceledState($order)) {
                    $status = 'canceled';
                } elseif ($this->isInClosedState($order)) {
                    $status = 'closed';
                }
            }
        
            $order->status = $status;
            $order->save();
        
            Event::dispatch('sales.order.update-status.after', $order);
        }
        
        /**
         * Collect totals.
         *
         * @param  \Webkul\Sales\Contracts\Order  $order
         * @return mixed
         */
        public function collectTotals($order)
        {
            // order invoice total
            $order->sub_total_invoiced = $order->base_sub_total_invoiced = 0;
            $order->shipping_invoiced = $order->base_shipping_invoiced = 0;
            $order->tax_amount_invoiced = $order->base_tax_amount_invoiced = 0;
            $order->discount_invoiced = $order->base_discount_invoiced = 0;
        
            foreach ($order->invoices as $invoice) {
                $order->sub_total_invoiced += $invoice->sub_total;
                $order->base_sub_total_invoiced += $invoice->base_sub_total;
        
                $order->shipping_invoiced += $invoice->shipping_amount;
                $order->base_shipping_invoiced += $invoice->base_shipping_amount;
        
                $order->tax_amount_invoiced += $invoice->tax_amount;
                $order->base_tax_amount_invoiced += $invoice->base_tax_amount;
        
                $order->discount_invoiced += $invoice->discount_amount;
                $order->base_discount_invoiced += $invoice->base_discount_amount;
            }
        
            $order->grand_total_invoiced = $order->sub_total_invoiced + $order->shipping_invoiced + $order->tax_amount_invoiced - $order->discount_invoiced;
            $order->base_grand_total_invoiced = $order->base_sub_total_invoiced + $order->base_shipping_invoiced + $order->base_tax_amount_invoiced - $order->base_discount_invoiced;
        
            // order refund total
            $order->sub_total_refunded = $order->base_sub_total_refunded = 0;
            $order->shipping_refunded = $order->base_shipping_refunded = 0;
            $order->tax_amount_refunded = $order->base_tax_amount_refunded = 0;
            $order->discount_refunded = $order->base_discount_refunded = 0;
            $order->grand_total_refunded = $order->base_grand_total_refunded = 0;
        
            foreach ($order->refunds as $refund) {
                $order->sub_total_refunded += $refund->sub_total;
                $order->base_sub_total_refunded += $refund->base_sub_total;
        
                $order->shipping_refunded += $refund->shipping_amount;
                $order->base_shipping_refunded += $refund->base_shipping_amount;
        
                $order->tax_amount_refunded += $refund->tax_amount;
                $order->base_tax_amount_refunded += $refund->base_tax_amount;
        
                $order->discount_refunded += $refund->discount_amount;
                $order->base_discount_refunded += $refund->base_discount_amount;
        
                $order->grand_total_refunded += $refund->adjustment_refund - $refund->adjustment_fee;
                $order->base_grand_total_refunded += $refund->base_adjustment_refund - $refund->base_adjustment_fee;
            }
        
            $order->grand_total_refunded += $order->sub_total_refunded + $order->shipping_refunded + $order->tax_amount_refunded - $order->discount_refunded;
            $order->base_grand_total_refunded += $order->base_sub_total_refunded + $order->base_shipping_refunded + $order->base_tax_amount_refunded - $order->base_discount_refunded;
        
            $order->save();
        
            return $order;
        }
        
        /**
         * This method will find order if id is given else pass the order as it is.
         *
         * @param  \Webkul\Sales\Models\Order|int  $orderOrId
         * @return \Webkul\Sales\Contracts\Order
         */
        private function resolveOrderInstance($orderOrId)
        {
            return $orderOrId instanceof OrderModel
                ? $orderOrId
                : $this->findOrFail($orderOrId);
        }
        

        }

        In order repoistory I define the InvoiceRepository it's generate the error:

        This page isn’t workinglocalhost is currently unable to handle this request.
        HTTP ERROR 500

        I use the laravel version 10 and vue 3 php version 8.1

        please can you help me how can I fix this error.

        Thanks a lot

        1 Reply Last reply Reply Quote 0
        3 out of 3
        • First post
          3/3
          Last post