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

      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

        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
        • R
          Rimeri 0 last edited by

          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
          • First post
            Last post