/home/techb158/immovalet.com/platform/plugins/ecommerce/src/Http/Controllers
Edit: /home/techb158/immovalet.com/platform/plugins/ecommerce/src/Http/Controllers/OrderController.php (40398B)
orderRepository = $orderRepository;
$this->customerRepository = $customerRepository;
$this->orderHistoryRepository = $orderHistoryRepository;
$this->productRepository = $productRepository;
$this->shipmentRepository = $shipmentRepository;
$this->orderAddressRepository = $orderAddressRepository;
$this->paymentRepository = $paymentRepository;
$this->storeLocatorRepository = $storeLocatorRepository;
$this->orderProductRepository = $orderProductRepository;
$this->addressRepository = $addressRepository;
}
/**
* @param OrderTable $dataTable
* @return Factory|View
* @throws Throwable
*/
public function index(OrderTable $dataTable)
{
page_title()->setTitle(trans('plugins/ecommerce::order.name'));
return $dataTable->renderTable();
}
/**
* @return Factory|View
*/
public function create()
{
Assets::addStylesDirectly(['vendor/core/plugins/ecommerce/css/ecommerce.css'])
->addScriptsDirectly([
'vendor/core/plugins/ecommerce/libraries/jquery.textarea_autosize.js',
'vendor/core/plugins/ecommerce/js/order-create.js',
])
->addScripts(['blockui', 'input-mask']);
page_title()->setTitle(trans('plugins/ecommerce::order.create'));
return view('plugins/ecommerce::orders.create');
}
/**
* @param CreateOrderRequest $request
* @param BaseHttpResponse $response
*/
public function store(CreateOrderRequest $request, BaseHttpResponse $response)
{
$request->merge([
'amount' => $request->input('amount') + $request->input('shipping_amount') - $request->input('discount_amount'),
'currency_id' => get_application_currency_id(),
'user_id' => $request->input('customer_id') ?? 0,
'shipping_method' => $request->input('shipping_method', ShippingMethodEnum::DEFAULT),
'shipping_option' => $request->input('shipping_option'),
'shipping_amount' => $request->input('shipping_amount'),
'tax_amount' => session('tax_amount', 0),
'sub_total' => $request->input('amount'),
'coupon_code' => $request->input('coupon_code'),
'discount_amount' => $request->input('discount_amount'),
'discount_description' => $request->input('discount_description'),
'description' => $request->input('note'),
'is_confirmed' => 1,
'status' => OrderStatusEnum::PROCESSING,
]);
foreach ($request->input('products', []) as $productItem) {
$product = $this->productRepository->findById(Arr::get($productItem, 'id'));
if (!$product) {
continue;
}
if ($product->with_storehouse_management && $product->quantity < Arr::get($productItem, 'quantity', 1)) {
return $response
->setError()
->setMessage(trans('plugins/ecommerce::order.one_or_more_products_dont_have_enough_quantity'));
}
}
$order = $this->orderRepository->createOrUpdate($request->input());
if ($order) {
$this->orderHistoryRepository->createOrUpdate([
'action' => 'create_order_from_payment_page',
'description' => trans('plugins/ecommerce::order.create_order_from_payment_page'),
'order_id' => $order->id,
]);
$this->orderHistoryRepository->createOrUpdate([
'action' => 'create_order',
'description' => trans('plugins/ecommerce::order.new_order',
['order_id' => get_order_code($order->id)]),
'order_id' => $order->id,
]);
$this->orderHistoryRepository->createOrUpdate([
'action' => 'confirm_order',
'description' => trans('plugins/ecommerce::order.order_was_verified_by'),
'order_id' => $order->id,
'user_id' => Auth::id(),
]);
$payment = $this->paymentRepository->createOrUpdate([
'amount' => $order->amount,
'currency' => cms_currency()->getDefaultCurrency()->title,
'payment_channel' => $request->input('payment_method'),
'status' => $request->input('payment_status', PaymentStatusEnum::PENDING),
'payment_type' => 'confirm',
'order_id' => $order->id,
'charge_id' => Str::upper(Str::random(10)),
'user_id' => Auth::id(),
]);
$order->payment_id = $payment->id;
$order->save();
if ($request->input('payment_status') === PaymentStatusEnum::COMPLETED) {
$this->orderHistoryRepository->createOrUpdate([
'action' => 'confirm_payment',
'description' => trans('plugins/ecommerce::order.payment_was_confirmed_by', [
'money' => format_price($order->amount),
]),
'order_id' => $order->id,
'user_id' => Auth::id(),
]);
}
if ($request->input('customer_address.name')) {
$this->orderAddressRepository->create([
'name' => $request->input('customer_address.name'),
'phone' => $request->input('customer_address.phone'),
'email' => $request->input('customer_address.email'),
'state' => $request->input('customer_address.state'),
'city' => $request->input('customer_address.city'),
'zip_code' => $request->input('customer_address.zip_code'),
'country' => $request->input('customer_address.country'),
'address' => $request->input('customer_address.address'),
'order_id' => $order->id,
]);
} elseif ($request->input('customer_id')) {
$customer = $this->customerRepository->findById($request->input('customer_id'));
$this->orderAddressRepository->create([
'name' => $customer->name,
'phone' => $customer->phone,
'email' => $customer->email,
'order_id' => $order->id,
]);
}
foreach ($request->input('products', []) as $productItem) {
$product = $this->productRepository->findById(Arr::get($productItem, 'id'));
if (!$product) {
continue;
}
$data = [
'order_id' => $order->id,
'product_id' => $product->id,
'product_name' => $product->name,
'qty' => Arr::get($productItem, 'quantity', 1),
'weight' => $product->weight,
'price' => $product->front_sale_price,
'tax_amount' => 0,
'options' => [],
];
$this->orderProductRepository->create($data);
$ids = [$product->id];
if ($product->is_variation && $product->original_product) {
$ids[] = $product->original_product->id;
}
$this->productRepository
->getModel()
->whereIn('id', $ids)
->where('with_storehouse_management', 1)
->where('quantity', '>=', Arr::get($productItem, 'quantity', 1))
->decrement('quantity', Arr::get($productItem, 'quantity', 1));
}
}
return $response
->setData($order)
->setMessage(trans('core/base::notices.create_success_message'));
}
/**
* @param int $id
* @return Factory|View
*/
public function edit($id)
{
Assets::addStylesDirectly(['vendor/core/plugins/ecommerce/css/ecommerce.css'])
->addScriptsDirectly([
'vendor/core/plugins/ecommerce/libraries/jquery.textarea_autosize.js',
'vendor/core/plugins/ecommerce/js/order.js',
])
->addScripts(['blockui', 'input-mask']);
$order = $this->orderRepository->findOrFail($id, ['products', 'user']);
page_title()->setTitle(trans('plugins/ecommerce::order.edit_order', ['code' => get_order_code($id)]));
$weight = 0;
foreach ($order->products as $product) {
if ($product && $product->weight) {
$weight += $product->weight;
}
}
$defaultStore = get_primary_store_locator();
return view('plugins/ecommerce::orders.edit', compact('order', 'weight', 'defaultStore'));
}
/**
* @param int $id
* @param UpdateOrderRequest $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse
*/
public function update($id, UpdateOrderRequest $request, BaseHttpResponse $response)
{
$order = $this->orderRepository->createOrUpdate($request->input(), ['id' => $id]);
event(new UpdatedContentEvent(ORDER_MODULE_SCREEN_NAME, $request, $order));
return $response
->setPreviousUrl(route('orders.index'))
->setMessage(trans('core/base::notices.update_success_message'));
}
/**
* @param int $id
* @param Request $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse
*/
public function destroy($id, Request $request, BaseHttpResponse $response)
{
$order = $this->orderRepository->findOrFail($id);
try {
$this->orderRepository->deleteBy(['id' => $id]);
event(new DeletedContentEvent(ORDER_MODULE_SCREEN_NAME, $request, $order));
return $response->setMessage(trans('core/base::notices.delete_success_message'));
} catch (Exception $exception) {
return $response
->setError()
->setMessage($exception->getMessage());
}
}
/**
* @param Request $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse
*/
public function deletes(Request $request, BaseHttpResponse $response)
{
$ids = $request->input('ids');
if (empty($ids)) {
return $response
->setError()
->setMessage(trans('core/base::notices.no_select'));
}
foreach ($ids as $id) {
$order = $this->orderRepository->findOrFail($id);
$this->orderRepository->delete($order);
event(new DeletedContentEvent(ORDER_MODULE_SCREEN_NAME, $request, $order));
}
return $response->setMessage(trans('core/base::notices.delete_success_message'));
}
/**
* @param int $orderId
* @return BinaryFileResponse
*/
public function getGenerateInvoice($orderId)
{
$order = $this->orderRepository->findOrFail($orderId);
$invoice = OrderHelper::generateInvoice($order);
return response()->download($invoice)->deleteFileAfterSend();
}
/**
* @param Request $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse
* @throws Throwable
*/
public function postConfirm(Request $request, BaseHttpResponse $response)
{
$order = $this->orderRepository->findOrFail($request->input('order_id'));
$order->is_confirmed = 1;
if ($order->status == OrderStatusEnum::PENDING) {
$order->status = OrderStatusEnum::PROCESSING;
}
$this->orderRepository->createOrUpdate($order);
$this->orderHistoryRepository->createOrUpdate([
'action' => 'confirm_order',
'description' => trans('plugins/ecommerce::order.order_was_verified_by'),
'order_id' => $order->id,
'user_id' => Auth::id(),
]);
$payment = $this->paymentRepository->getFirstBy(['order_id' => $order->id]);
if ($payment) {
$payment->user_id = Auth::id();
$payment->save();
}
$mailer = EmailHandler::setModule(ECOMMERCE_MODULE_SCREEN_NAME);
if ($mailer->templateEnabled('order_confirm')) {
OrderHelper::setEmailVariables($order);
$mailer->sendUsingTemplate(
'order_confirm',
$order->user->email ?: $order->address->email
);
}
return $response->setMessage(trans('plugins/ecommerce::order.confirm_order_success'));
}
/**
* @param int $id
* @param BaseHttpResponse $response
* @return BaseHttpResponse
* @throws Throwable
*/
public function postResendOrderConfirmationEmail($id, BaseHttpResponse $response)
{
$order = $this->orderRepository->findOrFail($id);
$result = OrderHelper::sendOrderConfirmationEmail($order);
if (!$result) {
return $response
->setError()
->setMessage(trans('plugins/ecommerce::order.error_when_sending_email'));
}
return $response->setMessage(trans('plugins/ecommerce::order.sent_confirmation_email_success'));
}
/**
* @param int $orderId
* @param HandleShippingFeeService $shippingFeeService
* @param Request $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse|Factory|View
* @throws Throwable
*/
public function getShipmentForm(
$orderId,
HandleShippingFeeService $shippingFeeService,
Request $request,
BaseHttpResponse $response
) {
$order = $this->orderRepository->findOrFail($orderId);
$weight = 0;
if ($request->has('weight')) {
$weight = $request->input('weight');
} else {
foreach ($order->products as $product) {
if ($product && $product->weight) {
$weight += $product->weight;
}
}
}
$weight = $weight > 0.1 ? $weight : 0.1;
$shippingData = [
'address' => $order->address->address,
'country' => $order->address->country,
'state' => $order->address->state,
'city' => $order->address->city,
'weight' => $weight,
'order_total' => $order->amount,
];
$shipping = $shippingFeeService->execute($shippingData);
$storeLocators = $this->storeLocatorRepository->allBy(['is_shipping_location' => true]);
$url = route('orders.create-shipment', $order->id);
if ($request->has('view')) {
return view('plugins/ecommerce::orders.shipment-form',
compact('order', 'weight', 'shipping', 'storeLocators', 'url'));
}
return $response->setData(view('plugins/ecommerce::orders.shipment-form',
compact('order', 'weight', 'shipping', 'storeLocators', 'url'))->render());
}
/**
* @param int $id
* @param CreateShipmentRequest $request
* @param BaseHttpResponse $response
* @param ShipmentHistoryInterface $shipmentHistoryRepository
* @return BaseHttpResponse
* @throws FileNotFoundException
* @throws Throwable
*/
public function postCreateShipment(
$id,
CreateShipmentRequest $request,
BaseHttpResponse $response,
ShipmentHistoryInterface $shipmentHistoryRepository
) {
$order = $this->orderRepository->findOrFail($id);
$result = $response;
$products = [];
$weight = 0;
foreach ($order->products as $orderProduct) {
$products[] = [
'name' => $orderProduct->product_name,
'weight' => $orderProduct->weight ?? 0.1,
'quantity' => $orderProduct->qty,
];
$weight += $orderProduct->weight ?? 0.1;
}
$weight = $weight > 0.1 ? $weight : 0.1;
$shipment = [
'order_id' => $order->id,
'user_id' => Auth::id(),
'weight' => $weight,
'note' => $request->input('note'),
'cod_amount' => $request->input('cod_amount') ?? ($order->payment->status !== PaymentStatusEnum::COMPLETED ? $order->amount : 0),
'cod_status' => 'pending',
'type' => $request->input('method'),
'status' => ShippingStatusEnum::DELIVERING,
'price' => $order->shipping_amount,
'store_id' => $request->input('store_id'),
];
$store = $this->storeLocatorRepository->findById($request->input('store_id'));
if (!$store) {
$defaultStore = $this->storeLocatorRepository->getFirstBy(['is_primary' => true]);
$shipment['store_id'] = $defaultStore ?? ($defaultStore ? $defaultStore->id : null);
}
switch ($request->input('method')) {
default:
$result = $result->setMessage(trans('plugins/ecommerce::order.order_was_sent_to_shipping_team'));
break;
}
if (!$result->isError()) {
$this->orderRepository->createOrUpdate([
'status' => OrderStatusEnum::DELIVERING,
'shipping_method' => $request->input('method'),
'shipping_option' => $request->input('option'),
], compact('id'));
$shipment = $this->shipmentRepository->createOrUpdate($shipment);
$mailer = EmailHandler::setModule(ECOMMERCE_MODULE_SCREEN_NAME);
if ($mailer->templateEnabled('customer_delivery_order')) {
OrderHelper::setEmailVariables($order);
$mailer->sendUsingTemplate(
'customer_delivery_order',
$order->user->email ?: $order->address->email
);
}
$this->orderHistoryRepository->createOrUpdate([
'action' => 'create_shipment',
'description' => $result->getMessage() . ' ' . trans('plugins/ecommerce::order.by_username'),
'order_id' => $id,
'user_id' => Auth::id(),
]);
$shipmentHistoryRepository->createOrUpdate([
'action' => 'create_from_order',
'description' => trans('plugins/ecommerce::order.shipping_was_created_from'),
'shipment_id' => $shipment->id,
'order_id' => $id,
'user_id' => Auth::id(),
]);
}
return $result;
}
/**
* @param int $id
* @param BaseHttpResponse $response
* @return BaseHttpResponse
*/
public function postCancelShipment($id, BaseHttpResponse $response)
{
$shipment = $this->shipmentRepository->createOrUpdate(['status' => ShippingStatusEnum::CANCELED],
compact('id'));
$this->orderHistoryRepository->createOrUpdate([
'action' => 'cancel_shipment',
'description' => trans('plugins/ecommerce::order.shipping_was_canceled_by'),
'order_id' => $shipment->order_id,
'user_id' => Auth::id(),
]);
return $response
->setData([
'status' => ShippingStatusEnum::CANCELED,
'status_text' => ShippingStatusEnum::CANCELED()->label(),
])
->setMessage(trans('plugins/ecommerce::order.shipping_was_canceled_success'));
}
/**
* @param int $id
* @param AddressRequest $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse
* @throws Throwable
*/
public function postUpdateShippingAddress($id, AddressRequest $request, BaseHttpResponse $response)
{
$address = $this->orderAddressRepository->createOrUpdate($request->input(), compact('id'));
if (!$address) {
abort(404);
}
return $response
->setData([
'line' => view('plugins/ecommerce::orders.shipping-address.line', compact('address'))->render(),
'detail' => view('plugins/ecommerce::orders.shipping-address.detail', compact('address'))->render(),
])
->setMessage(trans('plugins/ecommerce::order.update_shipping_address_success'));
}
/**
* @param int $id
* @param BaseHttpResponse $response
* @return BaseHttpResponse
* @throws Throwable
*/
public function postCancelOrder($id, BaseHttpResponse $response)
{
$order = $this->orderRepository->findOrFail($id);
$this->orderRepository->createOrUpdate(['status' => OrderStatusEnum::CANCELED, 'is_confirmed' => true],
compact('id'));
foreach ($order->products as $orderProduct) {
$product = $orderProduct->product;
$product->quantity += $orderProduct->qty;
if ($product->is_variation) {
$originalProduct = $product->original_product;
$originalProduct->quantity += $orderProduct->qty;
$originalProduct->save();
}
$product->save();
}
$this->orderHistoryRepository->createOrUpdate([
'action' => 'cancel_order',
'description' => trans('plugins/ecommerce::order.order_was_canceled_by'),
'order_id' => $order->id,
'user_id' => Auth::id(),
]);
$mailer = EmailHandler::setModule(ECOMMERCE_MODULE_SCREEN_NAME);
if ($mailer->templateEnabled('customer_cancel_order')) {
OrderHelper::setEmailVariables($order);
$mailer->sendUsingTemplate(
'customer_cancel_order',
$order->user->email ?: $order->address->email
);
}
return $response->setMessage(trans('plugins/ecommerce::order.customer.messages.cancel_success'));
}
/**
* @param int $id
* @param BaseHttpResponse $response
* @return BaseHttpResponse
* @throws FileNotFoundException
* @throws Throwable
*/
public function postConfirmPayment($id, BaseHttpResponse $response)
{
$order = $this->orderRepository->findOrFail($id, ['payment']);
if ($order->status === OrderStatusEnum::PENDING) {
$order->status = OrderStatusEnum::PROCESSING;
}
$this->orderRepository->createOrUpdate($order);
$payment = $order->payment;
$payment->status = PaymentStatusEnum::COMPLETED;
$this->paymentRepository->createOrUpdate($payment);
$mailer = EmailHandler::setModule(ECOMMERCE_MODULE_SCREEN_NAME);
if ($mailer->templateEnabled('order_confirm_payment')) {
OrderHelper::setEmailVariables($order);
$mailer->sendUsingTemplate(
'order_confirm_payment',
$order->user->email ?: $order->address->email
);
}
$this->orderHistoryRepository->createOrUpdate([
'action' => 'confirm_payment',
'description' => trans('plugins/ecommerce::order.payment_was_confirmed_by', [
'money' => format_price($order->amount),
]),
'order_id' => $order->id,
'user_id' => Auth::id(),
]);
return $response->setMessage(trans('plugins/ecommerce::order.confirm_payment_success'));
}
/**
* @param int $id
* @param RefundRequest $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse
*/
public function postRefund($id, RefundRequest $request, BaseHttpResponse $response)
{
$order = $this->orderRepository->findOrFail($id);
if ($request->input('refund_amount') > ($order->payment->amount - $order->payment->refunded_amount)) {
return $response
->setError()
->setMessage(trans('plugins/ecommerce::order.refund_amount_invalid', [
'price' => format_price($order->payment->amount - $order->payment->refunded_amount,
get_application_currency()),
]));
}
$hasError = false;
foreach ($request->input('products', []) as $productId => $quantity) {
$orderProduct = $this->orderProductRepository->getFirstBy([
'product_id' => $productId,
'order_id' => $id,
]);
if ($quantity > ($orderProduct->qty - $orderProduct->restock_quantity)) {
$hasError = true;
$response
->setError()
->setMessage(trans('plugins/ecommerce::order.number_of_products_invalid'));
break;
}
}
if ($hasError) {
return $response;
}
$payment = $order->payment;
if (!$payment) {
return $response
->setError()
->setMessage(trans('plugins/ecommerce::order.cannot_found_payment_for_this_order'));
}
$refundAmount = $request->input('refund_amount');
if ($paymentService = get_payment_is_support_refund_online($payment)) {
$paymentResponse = (new $paymentService);
if (method_exists($paymentService, 'setCurrency')) {
$paymentResponse = $paymentResponse->setCurrency($payment->currency);
}
$optionRefunds = [
'refund_note' => $request->input('refund_note'),
'order_id' => $order->id
];
$paymentResponse = $paymentResponse->refundOrder($payment->charge_id, $refundAmount, $optionRefunds);
if (Arr::get($paymentResponse, 'error', true)) {
return $response
->setError()
->setMessage(Arr::get($paymentResponse, 'message', ''));
}
}
$payment->refunded_amount += $request->input('refund_amount');
if ($payment->refunded_amount == $payment->amount) {
$payment->status = PaymentStatusEnum::REFUNDED;
}
$payment->refund_note = $request->input('refund_note');
$this->paymentRepository->createOrUpdate($payment);
foreach ($request->input('products', []) as $productId => $quantity) {
$product = $this->productRepository->findById($productId);
if ($product && $product->with_storehouse_management) {
$product->quantity += $quantity;
$this->productRepository->createOrUpdate($product);
}
$orderProduct = $this->orderProductRepository->getFirstBy([
'product_id' => $productId,
'order_id' => $id,
]);
if ($orderProduct) {
$orderProduct->restock_quantity += $quantity;
$this->orderProductRepository->createOrUpdate($orderProduct);
}
}
if ($request->input('refund_amount', 0) > 0) {
$this->orderHistoryRepository->createOrUpdate([
'action' => 'refund',
'description' => trans('plugins/ecommerce::order.refund_success_with_price', [
'price' => format_price($request->input('refund_amount')),
]),
'order_id' => $order->id,
'user_id' => Auth::id(),
'extras' => json_encode([
'amount' => $request->input('refund_amount'),
'method' => $payment->payment_channel ?? PaymentMethodEnum::COD,
]),
]);
}
return $response->setMessage(trans('plugins/ecommerce::order.refund_success'));
}
/**
* @param Request $request
* @param BaseHttpResponse $response
* @param HandleShippingFeeService $shippingFeeService
* @return BaseHttpResponse
*/
public function getAvailableShippingMethods(
Request $request,
BaseHttpResponse $response,
HandleShippingFeeService $shippingFeeService
) {
$weight = 0;
$orderAmount = 0;
foreach ($request->input('products', []) as $productId) {
$product = $this->productRepository->findById($productId);
if ($product) {
$weight += $product->weight;
$orderAmount += $product->front_sale_price;
}
}
$weight = $weight > 0.1 ? $weight : 0.1;
$shippingData = [
'address' => $request->input('address'),
'country' => $request->input('country'),
'state' => $request->input('state'),
'city' => $request->input('city'),
'weight' => $weight,
'order_total' => $orderAmount,
];
$shipping = $shippingFeeService->execute($shippingData);
$result = [];
foreach ($shipping as $key => $shippingItem) {
foreach ($shippingItem as $subKey => $subShippingItem) {
$result[$key . ';' . $subKey . ';' . $subShippingItem['price']] = [
'name' => $subShippingItem['name'],
'price' => format_price($subShippingItem['price'], null, true),
];
}
}
return $response->setData($result);
}
/**
* @param ApplyCouponRequest $request
* @param HandleApplyCouponService $handleApplyCouponService
* @param BaseHttpResponse $response
* @return BaseHttpResponse
* @throws Throwable
*/
public function postApplyCoupon(
ApplyCouponRequest $request,
HandleApplyCouponService $handleApplyCouponService,
BaseHttpResponse $response
) {
$result = $handleApplyCouponService->applyCouponWhenCreatingOrderFromAdmin($request);
if ($result['error']) {
return $response
->setError()
->withInput()
->setMessage($result['message']);
}
return $response
->setData(Arr::get($result, 'data', []))
->setMessage(trans('plugins/ecommerce::order.applied_coupon_success',
['code' => $request->input('coupon_code')]));
}
/**
* @param Request $request
* @param BaseHttpResponse $response
* @return BaseHttpResponse|Factory|View
*/
public function getReorder(Request $request, BaseHttpResponse $response)
{
if (!$request->input('order_id')) {
return $response
->setError()
->setNextUrl(route('orders.index'))
->setMessage(trans('plugins/ecommerce::order.order_is_not_existed'));
}
page_title()->setTitle(trans('plugins/ecommerce::order.reorder'));
$order = $this->orderRepository->findById($request->input('order_id'));
if (!$order) {
return $response
->setError()
->setNextUrl(route('orders.index'))
->setMessage(trans('plugins/ecommerce::order.order_is_not_existed'));
}
$productIds = $order->products->pluck('product_id')->all();
$products = $this->productRepository
->getModel()
->whereIn('id', $productIds)
->get();
foreach ($products as &$availableProduct) {
$availableProduct->image_url = RvMedia::getImageUrl(Arr::first($availableProduct->images) ?? null, 'thumb',
false, RvMedia::getDefaultImage());
$availableProduct->price = $availableProduct->front_sale_price;
$availableProduct->product_name = $availableProduct->name;
$availableProduct->product_link = route('products.edit', $availableProduct->id);
$availableProduct->select_qty = 1;
$availableProduct->product_id = $availableProduct->id;
$orderProduct = $order->products->where('product_id', $availableProduct->id)->first();
if ($orderProduct) {
$availableProduct->select_qty = $orderProduct->qty;
}
foreach ($availableProduct->variations as &$variation) {
$variation->price = $variation->product->front_sale_price;
foreach ($variation->variationItems as &$variationItem) {
$variationItem->attribute_title = $variationItem->attribute->title;
}
}
}
$customer = null;
$customerAddresses = [];
$customerOrderNumbers = 0;
if ($order->user_id) {
$customer = $this->customerRepository->findById($order->user_id);
$customer->avatar = (string)$customer->avatar_url;
if ($customer) {
$customerOrderNumbers = $customer->orders()->count();
}
$customerAddresses = $customer->addresses->toArray();
}
$customerAddress = $order->address;
Assets::addStylesDirectly(['vendor/core/plugins/ecommerce/css/ecommerce.css'])
->addScriptsDirectly([
'vendor/core/plugins/ecommerce/libraries/jquery.textarea_autosize.js',
'vendor/core/plugins/ecommerce/js/order-create.js',
])
->addScripts(['blockui', 'input-mask']);
return view('plugins/ecommerce::orders.reorder', compact(
'order',
'products',
'productIds',
'customer',
'customerAddresses',
'customerAddress',
'customerOrderNumbers'
));
}
/**
* @param OrderIncompleteTable $dataTable
* @return Factory|View
* @throws Throwable
*/
public function getIncompleteList(OrderIncompleteTable $dataTable)
{
page_title()->setTitle(trans('plugins/ecommerce::order.incomplete_order'));
return $dataTable->renderTable();
}
/**
* @param int $id
* @return Factory|View
*/
public function getViewIncompleteOrder($id)
{
page_title()->setTitle(trans('plugins/ecommerce::order.incomplete_order'));
Assets::addStylesDirectly(['vendor/core/plugins/ecommerce/css/ecommerce.css'])
->addScriptsDirectly([
'vendor/core/plugins/ecommerce/libraries/jquery.textarea_autosize.js',
'vendor/core/plugins/ecommerce/js/order-incomplete.js',
]);
$order = $this->orderRepository
->getModel()
->where('id', $id)
->where('is_finished', 0)
->with(['products', 'user'])
->firstOrFail();
return view('plugins/ecommerce::orders.view-incomplete-order', compact('order'));
}
/**
* @param int $id
* @param BaseHttpResponse $response
* @return BaseHttpResponse
* @throws Throwable
*/
public function postSendOrderRecoverEmail($id, BaseHttpResponse $response)
{
$order = $this->orderRepository->findOrFail($id);
try {
$mailer = EmailHandler::setModule(ECOMMERCE_MODULE_SCREEN_NAME);
if ($mailer->templateEnabled('order_recover')) {
$order->dont_show_order_info_in_product_list = true;
OrderHelper::setEmailVariables($order);
$mailer->sendUsingTemplate(
'order_recover',
$order->user->email ?: $order->address->email
);
}
return $response->setMessage(trans('plugins/ecommerce::order.sent_email_incomplete_order_success'));
} catch (Exception $exception) {
return $response
->setError()
->setMessage(trans('plugins/ecommerce::order.error_when_sending_email'));
}
}
}