MAINHACK

Viewing / Editing File: OrderController.php

<?php

namespace App\Http\Controllers\Admin;

use App\CentralLogics\Helpers;
use App\CentralLogics\OrderLogic;
use App\Http\Controllers\Controller;
use App\Models\Order;
use App\Models\OrderDetail;
use App\Models\Admin;
use App\Models\Zone;
use App\Models\RestaurantWallet;
use App\Models\AdminWallet;
use App\Models\DeliveryManWallet;
use App\Models\DeliveryMan;
use App\Models\Category;
use App\Models\Food;
use App\Models\BusinessSetting;
use App\Models\ItemCampaign;
use Brian2694\Toastr\Facades\Toastr;
use Illuminate\Http\Request;
use Grimzy\LaravelMysqlSpatial\Types\Point;
use Illuminate\Support\Facades\DB;

class OrderController extends Controller
{
    public function list($status, Request $request)
    {
        if (session()->has('zone_filter') == false) {
            session()->put('zone_filter', 0);
        }

if(session()->has('order_filter'))
        {
            $request = json_decode(session('order_filter'));
        }
        
        Order::where(['checked' => 0])->update(['checked' => 1]);

$orders = Order::with(['customer', 'restaurant'])
        ->when(isset($request->zone), function($query)use($request){
            return $query->whereHas('restaurant', function($q)use($request){
                return $q->whereIn('zone_id',$request->zone);
            });
        })
        ->when($status == 'scheduled', function($query){
            return $query->whereRaw('created_at <> schedule_at');
        })
        ->when($status == 'searching_for_deliverymen', function($query){
            return $query->SearchingForDeliveryman();
        })
        ->when($status == 'pending', function($query){
            return $query->Pending();
        })
        ->when($status == 'accepted', function($query){
            return $query->AccepteByDeliveryman();
        })
        ->when($status == 'processing', function($query){
            return $query->Preparing();
        })
        ->when($status == 'food_on_the_way', function($query){
            return $query->FoodOnTheWay();
        })
        ->when($status == 'delivered', function($query){
            return $query->Delivered();
        })
        ->when($status == 'canceled', function($query){
            return $query->Canceled();
        })
        ->when($status == 'failed', function($query){
            return $query->failed();
        })
        ->when($status == 'refunded', function($query){
            return $query->Refunded();
        })
        ->when($status == 'scheduled', function($query){
            return $query->Scheduled();
        })
        ->when($status == 'on_going', function($query){
            return $query->Ongoing();
        })
        ->when(($status != 'all' && $status != 'scheduled' && $status != 'canceled' && $status != 'refund_requested' && $status != 'refunded'), function($query){
            return $query->OrderScheduledIn(30);
        })
        ->when(isset($request->vendor), function($query)use($request){
            return $query->whereHas('restaurant', function($query)use($request){
                return $query->whereIn('id',$request->vendor);
            });
        })
        ->when(isset($request->orderStatus) && $status == 'all', function($query)use($request){
            return $query->whereIn('order_status',$request->orderStatus);
        })
        ->when(isset($request->scheduled) && $status == 'all', function($query){
            return $query->scheduled();
        })
        ->when(isset($request->order_type), function($query)use($request){
            return $query->where('order_type', $request->order_type);
        })
        ->when(isset($request->from_date)&&isset($request->to_date)&&$request->from_date!=null&&$request->to_date!=null, function($query)use($request){
            return $query->whereBetween('created_at', [$request->from_date." 00:00:00",$request->to_date." 23:59:59"]);
        })
        ->Notpos()
        ->orderBy('schedule_at', 'desc')
        ->paginate(config('default_pagination'));
        $orderstatus = isset($request->orderStatus)?$request->orderStatus:[];
        $scheduled =isset($request->scheduled)?$request->scheduled:0;
        $vendor_ids =isset($request->vendor)?$request->vendor:[];
        $zone_ids =isset($request->zone)?$request->zone:[];
        $from_date =isset($request->from_date)?$request->from_date:null;
        $to_date =isset($request->to_date)?$request->to_date:null;
        $order_type =isset($request->order_type)?$request->order_type:null;
        $total = $orders->total();

return view('admin-views.order.list', compact('orders', 'status', 'orderstatus', 'scheduled', 'vendor_ids', 'zone_ids', 'from_date', 'to_date', 'total', 'order_type'));
    }
    
    public function dispatch_list($status, Request $request)
    {

if(session()->has('order_filter'))
        {
            $request = json_decode(session('order_filter'));
            $zone_ids = isset($request->zone)?$request->zone:0;
        }
        
        Order::where(['checked' => 0])->update(['checked' => 1]);
        
        $orders = Order::with(['customer', 'restaurant'])
        ->when(isset($request->zone), function($query)use($request){
            return $query->whereHas('restaurant', function($query)use($request){
                return $query->whereIn('zone_id',$request->zone);
            });
        })
        ->when($status == 'searching_for_deliverymen', function($query){
            return $query->SearchingForDeliveryman();
        })
        ->when($status == 'on_going', function($query){
            return $query->Ongoing();
        })
        ->when(isset($request->vendor), function($query)use($request){
            return $query->whereHas('restaurant', function($query)use($request){
                return $query->whereIn('id',$request->vendor);
            });
        })
        ->when(isset($request->from_date)&&isset($request->to_date)&&$request->from_date!=null&&$request->to_date!=null, function($query)use($request){
            return $query->whereBetween('created_at', [$request->from_date." 00:00:00",$request->to_date." 23:59:59"]);
        })
        ->Notpos()
        ->OrderScheduledIn(30)
        ->orderBy('schedule_at', 'desc')
        ->paginate(config('default_pagination'));

$orderstatus = isset($request->orderStatus)?$request->orderStatus:[];
        $scheduled =isset($request->scheduled)?$request->scheduled:0;
        $vendor_ids =isset($request->vendor)?$request->vendor:[];
        $zone_ids =isset($request->zone)?$request->zone:[];
        $from_date =isset($request->from_date)?$request->from_date:null;
        $to_date =isset($request->to_date)?$request->to_date:null;
        $total = $orders->total();

return view('admin-views.order.distaptch_list', compact('orders', 'status', 'orderstatus', 'scheduled', 'vendor_ids', 'zone_ids', 'from_date', 'to_date', 'total'));
    }

public function details(Request $request, $id)
    {
        
        $order = Order::with('details')->where(['id' => $id])->Notpos()->first();
        if (isset($order)) {
            if($order->restaurant->self_delivery_system)
            {
                $deliveryMen = DeliveryMan::where('restaurant_id',$order->restaurant_id)->available()->active()->get();
            }
            else
            {
                $deliveryMen = DeliveryMan::where('zone_id',$order->restaurant->zone_id)->available()->active()->get();
            }

$category = $request->query('category_id', 0);
            // $sub_category = $request->query('sub_category', 0);
            $categories = Category::active()->get();
            $keyword = $request->query('keyword', false);
            $key = explode(' ', $keyword);
            $products = Food::withoutGlobalScopes()->where('restaurant_id', $order->restaurant_id)
            ->when($category, function($query)use($category){
                $query->whereHas('category',function($q)use($category){
                    return $q->whereId($category)->orWhere('parent_id', $category);
                });
            })
            ->when($keyword, function($query)use($key){
                return $query->where(function ($q) use ($key) {
                    foreach ($key as $value) {
                        $q->orWhere('name', 'like', "%{$value}%");
                    }
                });
            })
            ->latest()->paginate(10);
            $editing=false;
            if($request->session()->has('order_cart'))
            {
                $cart = session()->get('order_cart');
                if(count($cart)>0 && $cart[0]->order_id == $order->id)
                {
                    $editing=true;
                }
                else
                {
                    session()->forget('order_cart');
                }
                
            }
            
            $deliveryMen=Helpers::deliverymen_list_formatting($deliveryMen);
          
            return view('admin-views.order.order-view', compact('order', 'deliveryMen','categories', 'products','category', 'keyword', 'editing'));
        } else {
            Toastr::info(trans('messages.no_more_orders'));
            return back();
        }
    }

public function search(Request $request){
        $key = explode(' ', $request['search']);
        $orders=Order::where(function ($q) use ($key) {
            foreach ($key as $value) {
                $q->orWhere('id', 'like', "%{$value}%")
                ->orWhere('order_status', 'like', "%{$value}%")
                ->orWhere('transaction_reference', 'like', "%{$value}%");
            }
        })->Notpos()->limit(50)->get();
        return response()->json([
            'view'=>view('admin-views.order.partials._table',compact('orders'))->render()
        ]);
    }

public function status(Request $request)
    {
        $order = Order::Notpos()->find($request->id);

if ($order['delivery_man_id'] == null && $request->order_status == 'out_for_delivery') {
            Toastr::warning(trans('messages.please_assign_deliveryman_first'));
            return back();
        }

if ($request->order_status == 'delivered' && $order['transaction_reference'] == null && $order['payment_method'] != 'cash_on_delivery') {
            Toastr::warning(trans('messages.add_your_paymen_ref_first'));
            return back();
        }

if ($request->order_status == 'delivered') {

if($order->transaction  == null)
            {
                if($order->payment_method="cash_on_delivery")
                {
                    if($order->order_type=='take_away')
                    {
                        $ol = OrderLogic::create_transaction($order,'restaurant', null);
                    }
                    else if($order->delivery_man_id)
                    {
                        $ol =  OrderLogic::create_transaction($order,'deliveryman', null);
                    }
                    else if($order->user_id)
                    {
                        $ol =  OrderLogic::create_transaction($order, false, null);
                    }
                }
                else
                {
                    $ol = OrderLogic::create_transaction($order,'admin', null);
                }
                if(!$ol)
                {
                    Toastr::warning(trans('messages.faield_to_create_order_transaction'));
                    return back();
                }
            }
            else if($order->delivery_man_id)
            {
                $order->transaction->update(['delivery_man_id'=>$order->delivery_man_id]);
            }

$order->payment_status = 'paid';
            if($order->delivery_man)
            {
                $dm = $order->delivery_man;
                $dm->current_orders = $dm->current_orders>1?$dm->current_orders-1:0;
                $dm->save();
                
                if($dm->earning == 1)
                {
                    $dmWallet = DeliveryManWallet::firstOrNew(
                        ['delivery_man_id' => $dm->id]
                    );
                    $dmWallet->total_earning = $dmWallet->total_earning + $order->original_delivery_charge;
                    $dmWallet->save();
                }

}
            $order->details->each(function($item, $key){
                if($item->food)
                {
                    $item->food->increment('order_count');
                }
            });
            $order->customer->increment('order_count');
        }
        else if($request->order_status == 'refunded')
        {
            if($order->payment_method == "cash_on_delivery" || $order->payment_status=="unpaid")
            {
                Toastr::warning(trans('messages.you_can_not_refund_a_cod_order'));
                return back();
            }

$rt = OrderLogic::refund_order($order);

if(!$rt)
            {
                Toastr::warning(trans('messages.faield_to_create_order_transaction'));
                return back();
            }

if($order->delivery_man)
            {
                $dm = $order->delivery_man;
                $dm->current_orders = $dm->current_orders>1?$dm->current_orders-1:0;
                $dm->save();
            }

}

$order->order_status = $request->order_status;
        $order[$request->order_status] = now();
        $order->save();
        
        if(!Helpers::send_order_notification($order))
        {
            Toastr::warning(trans('messages.push_notification_faild'));
        }

Toastr::success(trans('messages.order').trans('messages.status_updated'));
        return back();
    }

public function add_delivery_man($order_id, $delivery_man_id)
    {
        if ($delivery_man_id == 0) {
            return response()->json([
                    'errors'=>[
                        ['delivery_man_id'=> trans('messages.deliveryman').' '.trans('messages.not_found')]
                    ]
                ], 404);
        }
        $order = Order::Notpos()->find($order_id);

$deliveryman = DeliveryMan::where('id', $delivery_man_id)->available()->active()->first();
        if($order->delivery_man_id == $delivery_man_id)
        {
            return response()->json([
                'errors'=>[
                    ['delivery_man_id'=> trans('messages.order_already_assign_to_this_deliveryman')]
                ]
            ], 400);
        }
        if($deliveryman)
        {
            if($deliveryman->current_orders >= config('dm_maximum_orders'))
            {
                return response()->json([
                    'errors'=>[
                        ['current_orders'=> trans('messages.dm_maximum_order_exceed_warning')]
                    ]
                ], 404);
            }
            if($order->delivery_man)
            {
                $dm = $order->delivery_man;
                $dm->current_orders = $dm->current_orders>1?$dm->current_orders-1:0;
                $dm->save();

$data = [
                    'title' =>trans('messages.order_push_title'),
                    'description' => trans('messages.you_are_unassigned_from_a_order'),
                    'order_id' => '',
                    'image' => '',
                    'type'=> 'assign'
                ];
                Helpers::send_push_notif_to_device($dm->fcm_token, $data);

DB::table('user_notifications')->insert([
                    'data'=> json_encode($data),
                    'delivery_man_id'=>$dm->id,
                    'created_at'=>now(),
                    'updated_at'=>now()
                ]);
            }
            $order->delivery_man_id = $delivery_man_id;
            $order->order_status = in_array($order->order_status, ['pending', 'confirmed'])?'accepted':$order->order_status;
            $order->accepted = now();
            $order->save();

$deliveryman->current_orders = $deliveryman->current_orders + 1;
            $deliveryman->save();
            $fcm_token = $order->customer->cm_firebase_token;
            $value = Helpers::order_status_update_message('accepted');
            try {
                if ($value) {
                    $data = [
                        'title' =>trans('messages.order_push_title'),
                        'description' => $value,
                        'order_id' => $order['id'],
                        'image' => '',
                        'type'=> 'order_status'
                    ];
                    Helpers::send_push_notif_to_device($fcm_token, $data);
                    
                    DB::table('user_notifications')->insert([
                        'data'=> json_encode($data),
                        'user_id'=>$order->customer->id,
                        'created_at'=>now(),
                        'updated_at'=>now()
                    ]);
                }
                $data = [
                    'title' =>trans('messages.order_push_title'),
                    'description' => trans('messages.you_are_assigned_to_a_order'),
                    'order_id' => $order['id'],
                    'image' => '',
                    'type'=> 'assign'
                ];
                Helpers::send_push_notif_to_device($deliveryman->fcm_token, $data);
                DB::table('user_notifications')->insert([
                    'data'=> json_encode($data),
                    'delivery_man_id'=>$deliveryman->id,
                    'created_at'=>now(),
                    'updated_at'=>now()
                ]);

} catch (\Exception $e) {
                info($e);
                Toastr::warning(trans('messages.push_notification_faild'));
            }
            return response()->json([], 200);
        }
        return response()->json(['message'=> 'Deliveryman not available!'], 400);

}

public function update_shipping(Request $request,Order $order)
    {
        $request->validate([
            'contact_person_name' => 'required',
            'address_type' => 'required',
            'contact_person_number' => 'required',
        ]);
        if($request->latitude && $request->longitude)
        {
            $point = new Point($request->latitude,$request->longitude);
            $zone = Zone::where('id', $order->restaurant->zone_id)->contains('coordinates', $point)->first();
            if(!$zone)
            {
                Toastr::error(trans('messages.out_of_coverage'));
                return back();
            }
        }
        $address = [
            'contact_person_name' => $request->contact_person_name,
            'contact_person_number' => $request->contact_person_number,
            'address_type' => $request->address_type,
            'address' => $request->address,
            'longitude' => $request->longitude,
            'latitude' => $request->latitude
        ];

$order->delivery_address = json_encode($address);
        $order->save();
        Toastr::success(trans('messages.delivery_address_updated'));
        return back();
    }

public function generate_invoice($id)
    {
        $order = Order::Notpos()->where('id', $id)->first();
        return view('admin-views.order.invoice', compact('order'));
    }

public function add_payment_ref_code(Request $request, $id)
    {
        Order::Notpos()->where(['id' => $id])->update([
            'transaction_reference' => $request['transaction_reference']
        ]);

Toastr::success(trans('messages.payment_reference_code_is_added'));
        return back();
    }

public function restaurnt_filter($id)
    {
        session()->put('restaurnt_filter', $id);
        return back();
    }

public function filter(Request $request)
    {
        $request->validate([
            'from_date' => 'required_if:to_date,true',
            'to_date' => 'required_if:from_date,true',
        ]);
        session()->put('order_filter', json_encode($request->all()));
        return back();
    }
    public function filter_reset(Request $request)
    {
        session()->forget('order_filter');
        return back();
    }

public function add_to_cart(Request $request)
    {
        if($request->item_type=='food')
        {
            $product = Food::find($request->id);
        }
        else
        {
            $product = ItemCampaign::find($request->id);
        }

$data = new OrderDetail();
        if($request->order_details_id)
        {
            $data['id'] = $request->order_details_id;
        }
        
        $data['food_id'] = $request->item_type=='food'?$product->id:null;
        $data['item_campaign_id'] = $request->item_type=='campaign'?$product->id:null;
        $data['order_id']=$request->order_id;
        $str = '';
        $price = 0;
        $addon_price = 0;

//Gets all the choice values of customer choice option and generate a string like Black-S-Cotton
        foreach (json_decode($product->choice_options) as $key => $choice) {
            if ($str != null) {
                $str .= '-' . str_replace(' ', '', $request[$choice->name]);
            } else {
                $str .= str_replace(' ', '', $request[$choice->name]);
            }
        }
        $data['variant'] = json_encode([]);
        $data['variation'] = json_encode([]);
        if ($request->session()->has('order_cart') && !isset($request->cart_item_key)) {
            if (count($request->session()->get('order_cart')) > 0) {
                foreach ($request->session()->get('order_cart') as $key => $cartItem) {
                    if ($cartItem['food_id'] == $request['id'] && $cartItem['status']==true) {
                        if(count(json_decode($cartItem['variation'], true))>0)
                        {
                            if(json_decode($cartItem['variation'],true)[0]['type'] == $str)
                            {
                                return response()->json([
                                'data' => 1
                                ]);
                            }
                        }
                        else
                        {
                            return response()->json([
                               'data' => 1
                            ]);
                        }

}
                }

}
        }
        //Check the string and decreases quantity for the stock
        if ($str != null) {
            $count = count(json_decode($product->variations));
            for ($i = 0; $i < $count; $i++) {
                if (json_decode($product->variations)[$i]->type == $str) {
                    $price = json_decode($product->variations)[$i]->price;
                }
            }
            $data['variation'] = json_encode([["type"=>$str,"price"=>$price]]);
        } else {
            $price = $product->price;
        }

$data['quantity'] = $request['quantity'];
        $data['price'] = $price;
        $data['status'] = true;
        $data['discount_on_food'] = Helpers::product_discount_calculate($product, $price,$product->restaurant);
        $data["discount_type"] = "discount_on_product";
        $data["tax_amount"] = Helpers::tax_calculate($product, $price);
        $add_ons = [];
        $add_on_qtys = [];
        
        if($request['addon_id'])
        {
            foreach($request['addon_id'] as $id)
            {
                $addon_price+= $request['addon-price'.$id]*$request['addon-quantity'.$id];
                $add_on_qtys[]=$request['addon-quantity'.$id];
            } 
            $add_ons = $request['addon_id'];
        }

$addon_data = Helpers::calculate_addon_price(\App\Models\AddOn::whereIn('id',$add_ons)->get(), $add_on_qtys);
        $data['add_ons'] = json_encode($addon_data['addons']);
        $data['total_add_on_price'] = $addon_data['total_add_on_price'];
        // dd($data);
        $cart = $request->session()->get('order_cart', collect([]));
        if(isset($request->cart_item_key))
        {
            $cart[$request->cart_item_key] = $data;
            return response()->json([
                'data' => 2
            ]);
        }
        else
        {
            $cart->push($data);
        }

return response()->json([
            'data' => 0
        ]);
    }

public function remove_from_cart(Request $request)
    {
        $cart = $request->session()->get('order_cart', collect([]));
        $cart[$request->key]->status=false;
        $request->session()->put('order_cart', $cart);

return response()->json([],200);
    }

public function edit(Request $request, Order $order)
    {
        if($request->cancle)
        {
            if ($request->session()->has(['order_cart'])) {
                session()->forget(['order_cart']);
            }
            return back();
        }
        $cart = collect([]);
        foreach($order->details as $details)
        {
            unset($details['food_details']);
            $details['status']=true;
            $cart->push($details);
        }

if ($request->session()->has('order_cart')) {
            session()->forget('order_cart');
        } else {
            $request->session()->put('order_cart', $cart);
        }
        return back();
    }

public function update(Request $request, Order $order)
    {
        if(!$request->session()->has('order_cart'))
        {
            Toastr::error(trans('messages.order_data_not_found'));
            return back();
        }
        $cart = $request->session()->get('order_cart', collect([]));
        $restaurant = $order->restaurant;
        $coupon = null;
        $total_addon_price = 0;
        $product_price = 0;
        $restaurant_discount_amount = 0;
        if($order->coupon_code)
        {
            $coupon = Coupon::where(['code' => $request['coupon_code']])->first();
        }

foreach ($cart as $c) {
            if($c['status'] == true)
            {
                unset($c['status']);
                if ($c['item_campaign_id'] != null) 
                {
                    $product = ItemCampaign::find($c['item_campaign_id']);
                    if ($product) {

$price = $c['price'];

$product = Helpers::product_data_formatting($product);
            
                        $c->food_details = json_encode($product);
                        $c->updated_at = now();
                        if(isset($c->id))
                        {   
                            OrderDetail::where('id', $c->id)->update(
                                [
                                    'food_id' => $c->food_id,
                                    'item_campaign_id' => $c->item_campaign_id,
                                    'food_details' => $c->food_details,
                                    'quantity' => $c->quantity,
                                    'price' => $c->price,
                                    'tax_amount' => $c->tax_amount,
                                    'discount_on_food' => $c->discount_on_food,
                                    'discount_type' => $c->discount_type,
                                    'variant' => $c->variant,
                                    'variation' => $c->variation,
                                    'add_ons' => $c->add_ons,
                                    'total_add_on_price' => $c->total_add_on_price,
                                    'updated_at' => $c->updated_at
                                ]
                            );
                        }
                        else
                        {
                            $c->save();
                        }
                        
                        $total_addon_price += $c['total_add_on_price'];
                        $product_price += $price*$c['quantity'];
                        $restaurant_discount_amount += $c['discount_on_food']*$c['quantity'];
                    } else {
                        Toastr::error(trans('messages.food_not_found'));
                        return back();
                    }
                } else {
                    $product = Food::find($c['food_id']);
                    if ($product) {

$price = $c['price'];

$product = Helpers::product_data_formatting($product);
            
                        $c->food_details = json_encode($product);
                        $c->updated_at = now();
                        if(isset($c->id))
                        {   
                            OrderDetail::where('id', $c->id)->update(
                                [
                                'food_id' => $c->food_id,
                                'item_campaign_id' => $c->item_campaign_id,
                                'food_details' => $c->food_details,
                                'quantity' => $c->quantity,
                                'price' => $c->price,
                                'tax_amount' => $c->tax_amount,
                                'discount_on_food' => $c->discount_on_food,
                                'discount_type' => $c->discount_type,
                                'variant' => $c->variant,
                                'variation' => $c->variation,
                                'add_ons' => $c->add_ons,
                                'total_add_on_price' => $c->total_add_on_price,
                                'updated_at' => $c->updated_at
                            ]
                            );
                        }
                        else
                        {
                            $c->save();
                        }

$total_addon_price += $c['total_add_on_price'];
                        $product_price += $price*$c['quantity'];
                        $restaurant_discount_amount += $c['discount_on_food']*$c['quantity'];
                    } else {
                        Toastr::error(trans('messages.food_not_found'));
                        return back();
                    }
                }
            }
            else
            {
                $c->delete();
            }
        }

$restaurant_discount = Helpers::get_restaurant_discount($restaurant);
        if(isset($restaurant_discount))
        {
            if($product_price + $total_addon_price < $restaurant_discount['min_purchase'])
            {
                $restaurant_discount_amount = 0;
            }

if($restaurant_discount_amount > $restaurant_discount['max_discount'])
            {
                $restaurant_discount_amount = $restaurant_discount['max_discount'];
            }
        }
        $coupon_discount_amount = $coupon ? CouponLogic::get_discount($coupon, $product_price + $total_addon_price - $restaurant_discount_amount) : 0; 
        $total_price = $product_price + $total_addon_price - $restaurant_discount_amount - $coupon_discount_amount;

$tax = $restaurant->tax;
        $total_tax_amount= ($tax > 0)?(($total_price * $tax)/100):0;
        if($restaurant->minimum_order > $product_price + $total_addon_price )
        {
            Toastr::error(trans('messages.you_need_to_order_at_least', ['amount'=>$restaurant->minimum_order.' '.Helpers::currency_code()]));
            return back();
        }
        $free_delivery_over = BusinessSetting::where('key', 'free_delivery_over')->first()->value;
        if(isset($free_delivery_over))
        {
            if($free_delivery_over <= $product_price + $total_addon_price - $coupon_discount_amount - $restaurant_discount_amount)
            {
                $order->delivery_charge = 0;
            }
        }
        $total_order_ammount = $total_price + $total_tax_amount + $order->delivery_charge;
        $adjustment = $order->order_amount - $total_order_ammount;

$order->coupon_discount_amount = $coupon_discount_amount;
        $order->restaurant_discount_amount= $restaurant_discount_amount;
        $order->total_tax_amount= $total_tax_amount;
        $order->order_amount = $total_order_ammount;
        $order->adjusment = $adjustment;
        $order->edited = true;
        $order->save();
        session()->forget('order_cart');
        Toastr::success(trans('messages.order_updated_successfully'));
        return back();
    }

public function quick_view(Request $request)
    {

$product = $product = Food::findOrFail($request->product_id);
        $item_type = 'food';
        $order_id = $request->order_id;
        
        return response()->json([
            'success' => 1,
            'view' => view('admin-views.order.partials._quick-view', compact('product', 'order_id','item_type'))->render(),
        ]);
    }

public function quick_view_cart_item(Request $request)
    {
        $cart_item = session('order_cart')[$request->key];
        $order_id = $request->order_id;
        $item_key = $request->key;
        $product = $cart_item->food?$cart_item->food:$cart_item->campaign;
        $item_type = $cart_item->food?'food':'campaign';
        
        return response()->json([
            'success' => 1,
            'view' => view('admin-views.order.partials._quick-view-cart-item', compact('order_id','product', 'cart_item', 'item_key','item_type'))->render(),
        ]);
    }
}

Cancel / Back

[ MAINHACK ]

Viewing / Editing File: OrderController.php

Server Info

System Features

User Info