Edit File - File Manager

Edit File: OrderService.php

<?php
namespace App\Services;

use App\Jobs\ChangePaymentMethodNotify;
use App\Jobs\DelegateFinishOrder;
use App\Jobs\DelegatePayWithWallet;
use App\Jobs\StoreAcceptOrderNotify;
use App\Jobs\StoreDoneOrderNotify;
use App\Jobs\StoreNotify;
use App\Jobs\StorePrepareOrderNotify;
use App\Jobs\StoreDeliverOrderNotify;
use App\Jobs\StoreRefuseOrderNotify;
use App\Jobs\UserCancelOrderNotify;
use App\Models\Order;
use App\Models\OrderImage;
use App\Models\WaitingSettlementOrder;
use App\Models\OrderProduct;
use App\Models\OrderProductAdditive;
use App\Models\Product;
use App\Models\ProductAdditiveCategory;
use App\Models\ProductGroup;
use App\Models\Profit;
use App\Models\Room;
use App\Models\RoomMessage;
use App\Models\Setting;
use App\Models\Store;
use App\Models\StoreCommission;
use App\Models\User;
use App\Models\Vat;
use App\Models\WithdrawReason;
use App\Services\CouponService;
use App\Traits\ApiTrait;
use App\Traits\GeneralTrait;
use Auth;
use Illuminate\Support\Facades\File;
use Intervention\Image\Facades\Image;
use App\Models\Cart;

class OrderService
{
    use ApiTrait, GeneralTrait;
    public static function getdirectDistance($latitudeFrom, $longitudeFrom, $latitudeTo, $longitudeTo)
    {
        $in_km = 0;
        if ($latitudeFrom && $longitudeFrom && $latitudeTo && $longitudeTo){
            $earthRadius = 6371000;
            // convert from degrees to radians
            $latFrom = deg2rad($latitudeFrom);
            $lonFrom = deg2rad($longitudeFrom);
            $latTo   = deg2rad($latitudeTo);
            $lonTo   = deg2rad($longitudeTo);

$lonDelta = $lonTo - $lonFrom;
            $a        = pow(cos($latTo) * sin($lonDelta), 2) + pow(cos($latFrom) * sin($latTo) - sin($latFrom) * cos($latTo) * cos($lonDelta), 2);
            $b        = sin($latFrom) * sin($latTo) + cos($latFrom) * cos($latTo) * cos($lonDelta);
            $angle    = atan2(sqrt($a), $b);
            $in_km    = ($angle * $earthRadius) / 1000;
            $in_km += (40 / 100) * $in_km;
        }

$in_km = number_format((float) $in_km, 2, '.', '');
        return $in_km;
    }

public static function deliveryPrice($distance = 0)
    {
        $settings       = Setting::all()->pluck('value', 'key');
        $km_price       = $settings['km_price'];
        $starting_fee   = $settings['starting_fee'];
        $delivery_price = $starting_fee + ($distance * $km_price);

$data                           = [];
        $data['display_delivery_price'] = number_format($delivery_price, 2, '.', '');
        $data['delivery_price']         = $delivery_price;

return $data;
    }

public static function appPercentage($price = 0)
    {
        $settings       = Setting::all()->pluck('value', 'key');
        $app_percentage = (float) $price * ((float) $settings['app_percentage'] / 100);

return number_format($app_percentage, 2, '.', '');
    }

public static function addedValue($price = 0)
    {
        $settings    = Setting::all()->pluck('value', 'key');
        $added_value = $price * ($settings['added_value'] / 100);

return number_format($added_value, 2, '.', '');
    }

public static function uploadFile($file, $directory = 'unknown', $resize1 = null, $resize2 = null)
    {
        if (!File::isDirectory('assets/uploads/' . $directory)) {
            File::makeDirectory('assets/uploads/' . $directory, 0777, true, true);
        }

if (is_file($file)) {
            $img        = Image::make($file);
            $thumbsPath = 'assets/uploads/' . $directory;
            $name       = time() . '_' . rand(1111, 9999) . '.' . $file->getClientOriginalExtension();

if (null != $resize1) {
                $img->resize($resize1, $resize2, function ($constraint) {
                    $constraint->aspectRatio();
                });
                $thumbsPath = 'assets/uploads/' . $directory;
                $img->save($thumbsPath . '/' . $name);
            }
            $img->save($thumbsPath . '/' . $name);
            return (string) $name;
        } else {
            $name = time() . rand(1000000, 9999999) . '.png';
            $img  = Image::make(base64_decode($file));

if (null != $resize2) {
                $img->resize($resize1, $resize2, function ($constraint) {
                    $constraint->aspectRatio();
                });
                $thumbsPath = 'assets/uploads/' . $directory;
            }
            $img->save($thumbsPath . '/' . $name);
            return (string) $name;
        }

}

public static function initOrderRoom(array $data)
    {
        // init room
        $room = Room::create([
            'userone_id' => $data['userone_id'],
            'usertwo_id' => $data['usertwo_id'],
            'order_id'   => $data['order_id'],
            'status'     => 'open',
        ]);
        // send first message
        RoomMessage::create([
            'room_id'     => $room->id,
            'sender_id'   => $data['usertwo_id'],
            'receiver_id' => $data['userone_id'],
            'content'     => trans('order.delegate_welcome', ['name' => $data['delegate_name']]),
        ]);
    }

public static function restoreProduct($id)
    {
        $orderproducts = OrderProduct::where('order_id', $id)->get();

foreach ($orderproducts as $orderproduct) {
            $group = ProductGroup::find($orderproduct->group_id);
            if ($group) {
                $group->in_stock_qty += $orderproduct->qty;
                $group->update();
            }
        }
    }

public static function createOrder(array $data)
    {

$user    = auth('api')->user();
        $request = $data['request'];
        $data    = [];
        if (isset($request['store_id']) && isset($request['type']) == 'special_stores') {
            if (isset($request['store_id'])) {
                $store = Store::find($request['store_id']);
                if (!$store) {
                    $msg              = trans('stores.not_available');
                    $data['fail_msg'] = $msg;
                    return $data;
                }
                if ($store->openingHours()['open_status'] != true) {
                    $msg              = trans('stores.not_available');
                    $data['fail_msg'] = $msg;
                    return $data;
                }
//                if ($store->dayOpeningHours($request['deliver_date']  ,$request['deliver_time'])!= true) {
//                    $msg              = trans('order.time_not_available');
//                    $data['fail_msg'] = $msg;
//                    return $data;
//                }
            }
        }
        $carts = Cart::where('user_id', $user->id)->where('store_id', $request['store_id'])->get();
        $price = 0;
        $data  = (new CartService())->checkUserCartOrder($carts , $request['payment_type']);
        if (isset($data['fail_msg'])) {
            return $data;
        }
        //  order price
        $price            = number_format($data['price'], 2, '.', '');
        $request['price'] = $price;
        // added value
        $app_percentage            = static::appPercentage($price);
        $request['app_percentage'] = $app_percentage;

$added_value            = static::addedValue($price);
        $request['added_value'] = $added_value;
        // discount
        $discount = 0;
        if (isset($request['coupon'])) {
            $coupon_service      = new CouponService();
            $coupon_service_data = ['coupon' => $request['coupon'], 'delivery_price' => $price];
            $discount            = $coupon_service->enquiryCoupon($coupon_service_data);
            if (!$discount) {
                $msg              = trans('order.wrong_coupon_code');
                $data['fail_msg'] = $msg;
                return $data;
            } else {
                $coupon_service->useCoupon($coupon_service_data);
            }
        }

$discount            = number_format($discount, 2, '.', '');
        $request['discount'] = $discount;
        // total_price
        $total_price            = $price + $added_value - $discount;
        $total_price            = number_format($total_price, 2, '.', '');
        $request['total_price'] = $total_price;

// store the main order data
        $order = Order::create($request + ['user_id' => $user->id]);

foreach ($carts as $cart) {
            $group = ProductGroup::find($cart->group_id);
            $product = $group->product;
            // store order products // the main groups
            $orderproduct = OrderProduct::create(['order_id' => $order->id, 'product_id' => $product->id, 'group_id' => $group->id, 'price' => $group->price(), 'qty' => $cart->qty]);
            if ($cart->additives) {
                foreach (json_decode($cart->additives) as $id) {
                    $additive = ProductAdditiveCategory::find($id);
                    // store prder product additives
                    OrderProductAdditive::create(['product_additive_id' => $id, 'order_product_id' => $orderproduct->id, 'price' => $additive->price, 'qty' => $cart->qty]);
                }
            }
        }
        $carts->each->delete();
        // upload order images
        if (isset($request['images'])) {
            foreach ($request['images'] as $i) {
                $name = static::uploadFile($i, 'orders');
                OrderImage::create(['name' => $name, 'order_id' => $order->id]);
            }
        }

//send notifications
        static::sendNotifications($order);

return $order;
    }

public static function sendNotifications($order)
    {
        if ($order->store_id) {
            $notified_user = $order->store->user;
            dispatch(new StoreNotify($notified_user, $order));
        }

}

public static function orderEnquiry(array $data)
    {
        $request = $data['request'];
        // price
        $price = isset($request['price']) ? $request['price'] : 0;

// added value
        $added_value = static::addedValue($price);

// discount
        $discount   = 0;
        $coupon_msg = '';
        if (isset($request['coupon'])) {
            $coupon_service      = new CouponService();
            $coupon_service_data = ['coupon' => isset($request['coupon']) ? $request['coupon'] : '', 'delivery_price' => $price];
            $discount            = $coupon_service->enquiryCoupon($coupon_service_data);
            if (!$discount) {
                $msg              = trans('order.wrong_coupon_code');
                $data['fail_msg'] = $msg;
                return $data;
            } else {
                $coupon_msg = trans('order.success_coupon');
            }
        }

//here
        // total price
        $total_price = (float) $price + (float) $added_value - (float) $discount;
        $total_price = number_format($total_price, 2, '.', '');

$data                = [];
        $data['price']       = number_format($price, 2) ;
        $data['added_value'] = $added_value ;
        $data['discount']    = number_format($discount, 2) ;
        $data['total_price'] = $total_price;
        if (isset($request['coupon'])) {
            $data['has_coupon'] = true;
        } else {
            $data['has_coupon'] = false;
        }

$data['coupon_msg'] = $coupon_msg;
        return $data;

}

public static function changePaymentMethod(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // find order
        $order = $user->userOrders()->where('status', '!=', 'finished')->where('id', $request['order_id'])->first();
        if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        if ($order->payment_type != 'cash' && $order->payment_status == 'true') {
            $msg              = trans('order.cant_change_payment_method');
            $data['fail_msg'] = $msg;
            return $data;
        }
        $order->update(['payment_type' => $request['payment_type']]);
        //notify
        $notified_user = User::find($order->delegate_id);
        if ($notified_user) {
            dispatch(new ChangePaymentMethodNotify($notified_user, $order));
        }
    }

public static function finishOrder(array $data)
    {
        $order = $data['order'];
        // update user
        if ($user = $order->user) {
            $user->num_orders += 1;
            $user->total_bills += $order->total_price;
            $user->update();
        }
        // update delegate
        if ($delegate = $order->delegate) {
            $delegate->total_delivery_fees += $order->delivery_price;
            if ($order->payment_type == 'cash') {
                $delegate->wallet -= ($order->app_percentage + $order->added_value) - $order->discount;
            } else {
                $delegate->wallet += $order->price + $order->delivery_price;
            }
            $delegate->update();
        }
        $products_app_percentage = 0;
        if ($order->store && $order->store->has_contract == 'true') {
            $products_app_percentage = $order->store->commission_type == 'static_price' ? ($order->store->app_commission)
            : ($order->price * $order->store->app_commission / 100);
            $order->store->user->wallet -= $products_app_percentage;

if ($order->payment_type == 'cash') {
                $order->store->user->wallet -= ($order->app_percentage + $order->added_value) - $order->discount;
            } else {
                $order->store->user->wallet += $order->price ;
            }
            $order->store->user->update();

#store commission
            $store_commission = StoreCommission::create([
                'order_id'       => $order->id,
                'user_id'        => $order->store->user->id,
                'products_price' => $order->price,
                'commission'     => $products_app_percentage,
            ]);
        }

// app profits from delivery and from store there is contract
        $profit = Profit::create([
            'order_id'                => $order->id,
            'delivery_app_percentage' => $order->app_percentage,
            'added_value'             => $order->added_value,
            'total_delivery_profits'  => $order->added_value + $order->app_percentage,
            'products_app_percentage' => $products_app_percentage,
            'total_order_profits'     => $products_app_percentage + $order->added_value + $order->app_percentage,
        ]);
        $vat = Vat::create([
            'order_id'    => $order->id,
            'added_value' => $order->added_value,
            'store_vat'   => static::addedValue($profit->products_app_percentage),
            'total_vat'   => $order->added_value+static::addedValue($profit->products_app_percentage),
        ]);

// update order
        $order->update(['delivery_status' => 'delivered', 'status' => 'finished']);
        WaitingSettlementOrder::create([
            'order_id'     => $order->id,
            'provider_id'  => $order->store->user_id,
            'amount'       => $order->price - $order->app_percentage,
         ]);

if ($order->store && $order->store->user){
            dispatch(new DelegateFinishOrder($order->store->user , $order , auth('api')->user()));
        }

// //notify store if found
            // if ($order->store_id) {
            //     $notified_user = User::find($order->user_id);
            //     if ($notified_user) {
            //         dispatch(new DelegateFinishOrder($notified_user, $order, $order->store, 'store'));
            //     }
            // }
        
    }

public static function cancelOrder(array $data)
    {
        $order  = $data['order'];
        $reason = $data['reason'];
        // update order
        // self::restoreProduct($order->id);

$order->update(['status' => 'closed', 'close_reason' => $reason]);
        //notify
        if ($order->store) {
            $notified_user = $order->store->user;
            if ($notified_user) {
                dispatch(new UserCancelOrderNotify($notified_user, $order));
            }
        }
        if ($order->delegate) {
            $notified_user = $order->delegate;
            if ($notified_user) {
                dispatch(new UserCancelOrderNotify($notified_user, $order));
            }
        }
    }

public static function rejectOrder(array $data)
    {
        $order  = $data['order'];
        $reason = $data['reason'];
        if ($order->payment_status == 'true') {
            $msg              = trans('order.you_cannot_withdraw');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // update order
        WithdrawReason::create(['reason' => $reason, 'user_id' => auth('api')->user()->id, 'order_id' => $order->id]);

}

public static function payOrderWithWallet(array $data)
    {
        $order = $data['order'];
        $user  = $order->user;
        // update order
        $order->update(['payment_status' => 'true', 'payment_type' => 'wallet']);
        // update user wallet
        $user->wallet -= $order->total_price;
        $user->update();

//notify
        $notified_user = User::find($order->store?->user_id);
        // $pay_type      = 'wallet';
        if ($notified_user) {
            dispatch(new DelegatePayWithWallet($notified_user, $order));
        }

}
    public static function storeOrders(array $data)
    {
        $user  = Auth::user();
        $store = $user->store;

if ($data['status'] == 'inprogress') {
            $orders = Order::where('store_id', $store->id)
                ->whereIn('store_status', ['accepted', 'prepared'])
                ->orderBy('created_at', 'desc')
                ->get();
        } else {
            $orders = Order::where('store_id', $store->id)
                ->where('status', $data['status'])
                ->where('store_status', $data['store_status'])
                ->orderBy('created_at', 'desc')
                ->get();
        }
        return $orders;

}

public static function storeAcceptOrder(array $data)
    {
        $order = $data['order'];
        $user  = Auth::user();
        if ($order['status'] == 'closed') {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // update order
        $order->update(['store_status' => 'accepted' , 'status' => 'inprogress']);

//notify
        $notified_user = $order->user;
        dispatch(new StoreAcceptOrderNotify($notified_user, $order));

if ($order['needs_delivery'] == 'false') {
            $order->update(['status' => 'inprogress']);
        }

if ($order['needs_delivery'] == 'true') {
            //send notifications
            static::sendNotifications($order, $user, 'delegates');
        }
        return $data;

}

public static function storeRejectOrder(array $data)
    {
        $order = $data['order'];
        if ($order['status'] == 'closed') {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // update order
        // self::restoreProduct($order->id);
        $order->update(['store_status' => 'rejected', 'status' => 'closed' , 'close_reason' => $data['reason'] ?? '']);
        // if ($order->needs_delivery == 'true'){
        //     $citc = new CitcServices();
        //     $citc->rejectOrder($order->id);
        // }
        //notify
        $notified_user = $order->user;
        dispatch(new StoreRefuseOrderNotify($notified_user, $order));
        return $data;
    }

public static function storePreparedOrder(array $data)
    {
        $order = $data['order'];
        // update order
        $order->update(['store_status' => 'prepared']);
        //notify
        $notified_user = $order->user;
        dispatch(new StoreDoneOrderNotify($notified_user, $order));
    }
    
    public static function storePrepareOrder(array $data)
    {
        $order = $data['order'];
        // update order
        $order->update(['store_status' => 'prepare']);
        //notify
        $notified_user = $order->user;
        dispatch(new StorePrepareOrderNotify($notified_user, $order));

}

public static function storeDeliveryOrder(array $data)
    {
        $order = $data['order'];
        // update order
        $order->update(['store_status' => 'delivered']);
        if ($order->needs_delivery == 'false') {
            $order->update(['status' => 'finished']);
        }
        //notify
        $notified_user = $order->user;
        dispatch(new StoreDeliverOrderNotify($notified_user, $order));
    }

}

Back to File Manager