Edit File - File Manager

Edit File: OrderService.php

<?php

namespace App\Services;

use App\Models\Vat;
use App\Models\Room;
use App\Models\User;
use App\Models\Order;
use App\Models\Store;
use App\Models\Profit;
use App\Models\Product;
use App\Models\Setting;
use App\Jobs\StoreNotify;
use App\Models\OrderImage;
use App\Models\RoomMessage;
use App\Jobs\NewOrderNotify;
use App\Models\OrderProduct;
use App\Models\ProductGroup;
use App\Traits\GeneralTrait;
use App\Models\DeliveryOffer;
use App\Models\OrderServices;
use App\Models\WithdrawReason;
use App\Models\ProductAdditive;
use App\Models\StoreCommission;
use App\Services\CouponService;
use App\Jobs\DelegateFinishOrder;
use App\Jobs\UserFinishOrder;
use App\Jobs\OrderIntransitNotify;
use App\Jobs\StoreDoneOrderNotify;
use App\Jobs\DelegatePayWithWallet;
use App\Jobs\UserAcceptOfferNotify;
use App\Jobs\UserCancelOrderNotify;
use App\Jobs\UserRejectOfferNotify;
use App\Jobs\DelegateWithdrawNotify;
use App\Jobs\StoreAcceptOrderNotify;
use App\Jobs\StoreRefuseOrderNotify;
use App\Models\OrderProductAdditive;
use Illuminate\Support\Facades\File;
use App\Jobs\DelegateMakeOfferNotify;
use Intervention\Image\Facades\Image;
use App\Jobs\ChangePaymentMethodNotify;
use App\Jobs\DelegateAcceptOfferNotify;
use App\Jobs\DelegateCreateInvoiceNotify;
use App\Jobs\RefuseInvoiceNotify;
use App\Jobs\AcceptInvoiceNotify;
use App\Traits\Uploadable;
use App\Http\Resources\DelegatesResource;
use Log;
use App\Models\WaitingSettlementOrder;
use Nette\Utils\Random;
use Carbon\Carbon;

class OrderService
{
    use GeneralTrait,Uploadable;

public static function getdirectDistance($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 expected_price()
    {
        $settings    = Setting::all()->pluck('value', 'key');
        $data['min'] = $settings['min_expected_price'];
        $data['max'] = $settings['max_expected_price'];
        return $data;
    }

public static function uploadOne($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';
            // file_put_contents(base_path().'assets/uploads/' . $directory . '/' . $name, base64_decode($file));
            $img = Image::make(base64_decode($file));

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

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);
        }

public static function failMsg($msg = '', $code = 401): \Illuminate\Http\JsonResponse
    {
        return response()->json([
            'user_status' => auth('api')->user() ? auth('api')->user()->status : '',
            'key'         => 'fail',
            'msg'         => $msg,
            'code'        => $code,
        ]);
    }

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.welcome'),
        ]);
    }

public static function convert2english($string)
    {
        $newNumbers = range(0, 9);
        $arabic     = array('٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩');
        $string     = str_replace($arabic, $newNumbers, $string);
        return $string;
    }

public static function applyDeliveryOffer($request)
    {
        $discount = 0;
        $the_discount = 0;
        if (isset($request['store_id'])) {
            $store = Store::find($request['store_id']);
            if ($store->offer == 'true') {
                $amount = $store->offer_amount;
                $type = $store->offer_type;
                if ($type == 'percentage') {
                    $the_discount = $request['delivery_price'] * $amount / 100;
                } else {
                    $the_discount = $amount;
                }
                $discount += $the_discount;
                $discount = number_format($discount, 2, '.', '');
            }
        }
        return $discount;
    }

public static function createOrder(array $data)
    {
        $user    = auth('api')->user();
        $request = $data['request'];
        // store the main order data
        $order = Order::create($request + ['user_id' => $user->id,'ref_code'=>Random::generate(5)]);

// parcel delivery orders
        // upload order images
        if (isset($request['images'])) {
            $order->images()->delete();
            // Upload new images
            foreach($request['images'] as $image){
                $order->images()->create([
                'name' => static::uploadOne($image, 'order_images', true, 250, null),
                'order_id' => $order->id
            ]);
            }

}
        static::sendNotifications($order, $user);
        return $order;
    }

public static function delegateUploadOrderImages(array $data)
    {
        $user    = auth('api')->user();
        $request = $data['request'];
        // store the main order data
        $order = Order::find($request['order_id']);
        // parcel delivery orders
        // upload order images
        // if (isset($request['images'])) {
        //     $order->images()->delete();
        //     // Upload new images
        //     $order->images()->create([
        //         'name' => static::uploadOne($request['images'], 'order_images', true, 250, null),
        //         'order_id' => $order->id,
        //         'type'=>'delegate_image'
        //     ]);
        // }

if (isset($request['images'])) {
            // Upload new images
            foreach($request['images'] as $image){
                $order->images()->create([
                'name' => static::uploadOne($image, 'order_images', true, 250, null),
                'order_id'   => $order->id,
                'type'       => 'delegate_image',
            ]);
            }

}
        return $order;
    }

public static function addextraservices(array $data)
    {
        $user    = auth('api')->user();
        $request = $data['request'];

$order=Order::find($request['order_id']);

if (isset($request['order_services']) && $request['order_services']) {
               $price=0.0;
            foreach(json_decode($request['order_services']) as $service)
            {
            $service=(array)$service;
                OrderServices::create([
                 'order_id' =>$request['order_id'],
                 'name' => $service['name'],
                 'price' => $service['price'],
             ]);
             $price+=$service['price'];
            }
         }
        // $total= $order->total_price + $price;
        $added_value    = static::addedValue($order->remain +$price);

$order->total_price = $added_value +$order->remain +$price;
        $order->added_value = $added_value;
        $order->update();

return $order;
    }

public static function sendNotifications($order, $user, $type = 'all')
    {
        //location and max distance
        $lat          = isset($order->receive_lat) ? doubleval($order->receive_lat) : doubleval($user->lat);
        $long         = isset($order->receive_long) ? doubleval($order->receive_long) : doubleval($user->long);
        $max_distance = Setting::where('key', 'distance')->first()->value;
        $distance     = floatval(($max_distance * 0.1) / 15);
        $min_lat      = $lat - $distance;
        $min_long     = $long - $distance;
        $max_lat      = $lat + $distance;
        $max_long     = $long + $distance;
        //fetch nearest delegates
        $notified_users = User::where('status', 'active')
            ->where('approve','approved')
            ->where('active', 1)
            ->where('id', '!=', $user->id)
            ->orderBy('created_at', 'desc')
            ->where('type','delegate')
            ->whereHas('delegateJoinRequests', function ($query) use ($order) {
                $query->latest()->limit(1)->where(['car_type_id'=> $order->car_type_id,'category_id'=> $order->category_id]);
            })
            ->orderBy('created_at', 'desc')
            ->take(20)
            ->get();
       dispatch(new NewOrderNotify($notified_users, $order));
    }

public static function orderEnquiry(array $data)
    {
        $request = $data['request'];
        //delivery price
        $distance       = 0;
        $delivery_price = 0;
        if (isset($request['receive_lat']) && isset($request['receive_long']) && isset($request['deliver_lat']) && isset($request['deliver_long'])) {
            $distance       = static::directDistance($request['receive_lat'], $request['receive_long'], $request['deliver_lat'], $request['deliver_long']);
            $delivery_price = static::deliveryPrice($distance)['display_delivery_price'];
        }
        // shipping cost
        $shipping_price = Setting::where('key', 'shipping_price')->first()->value;
        // added value
        $added_value = static::addedValue($shipping_price + $delivery_price);
        $request['delivery_price'] = $delivery_price;
        $total_price = (float)$shipping_price + (float)$delivery_price + (float)$added_value ;
        $total_price = number_format($total_price, 2, '.', '');
        $data                   = [];
        $data['delivery_price'] = $delivery_price . ' ' . trans('stores.sar');
        $data['shipping_price'] = $shipping_price . ' ' . trans('stores.sar');
        $data['added_value']    = $added_value . ' ' . trans('stores.sar');
        $data['total_price']    = $total_price . ' ' . trans('stores.sar');
        return $data;
    }

public static function filterDelegates(array $data)
    {
        //location and max distance
        $lat          = isset($data['receive_lat']) ;
        $long         = isset($data['receive_long']);
        $max_distance = Setting::where('key', 'distance')->first()->value;
        $distance     = floatval(($max_distance * 0.1) / 15);
        $min_lat      = $lat - $distance;
        $min_long     = $long - $distance;
        $max_lat      = $lat + $distance;
        $max_long     = $long + $distance;

if (isset($data['provider_type'])) {
            if($data['provider_type']=='1'){
             $data['provider_type'] ='individual';
            }
         if($data['provider_type']=='2'){
             $data['provider_type'] ='company';
            }
           if($data['provider_type']=='0'){
             $data['provider_type'] ='all';
            }
        }

$notified_users = User::where('status', 'active')
            ->where('active', 1)
            ->where('approve', 'approved')
            ->where('type','!=','user')
            ->where('id', '!=', auth('api')->user()->id)
            ->orderBy('created_at', 'desc')
            ->where(function ($query) use ($data) {
                if($data['provider_type']=='individual'){
                    $query->where('type','delegate');
                    // ->whereHas('delegate_companies', function($q)use($data){
                    //  $q->where('category_id',$data['category_id'])
                    //      ->where('car_type_id',$data['car_type_id']);
                    // });
                }elseif($data['provider_type']=='company'){
                    $query->where('type','company');
                    // ->whereHas('delegate_joinrequests', function($q)use($data){
                    //     $q->where('category_id',$data['category_id'])
                    //         ->where('car_type_id',$data['car_type_id']);
                    // });
                }
            })
            ->orderBy('created_at', 'desc')
            ->get();
        return (DelegatesResource::collection($notified_users));
    }

public static function delegateAcceptOrder(array $data)
    {
        // $delegate = auth('api')->user();
        $delegate = User::findOrFail($data['delegate_id']);
        $request  = $data['request'];
        if (!isset($request['order_id'])) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // find order
        $order             = Order::where('id', $request['order_id'])->whereNotIn('status',['closed','canceled'])->first();

if (!isset($order)) {
            $msg              = trans('order.A request cannot be assigned to this delegate');
            $data['fail_msg'] = $msg;
            return $data;
        }

//        $delegate_max_debt = Setting::where('key', 'delegate_max_debt')->first()->value;
//        if ($delegate->wallet < 0 && $delegate->wallet <= (int) $delegate_max_debt * -1) {
//            $msg              = trans('order.you_have_to_charge');
//            $data['fail_msg'] = $msg;
//            return $data;
//        }
        if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

//        //check if delegate withdraw this order before
//        if ($delegate->withdrawReasons()->where('order_id', $order->id)->first()) {
//            $msg              = trans('order.you_withdraw_this_order');
//            $data['fail_msg'] = $msg;
//            return $data;
//        }
        // assign order to delegate
        $order->update(['delegate_id' => $delegate->id, 'delivery_status' => 'accepted', 'status' => 'inprogress', 'delegate_acceptance' => date('Y-m-d H:i:s')]);
        // create the room
        $room_data = ['userone_id' => $order->user_id, 'usertwo_id' => $delegate->id, 'order_id' => $order->id, 'delegate_name' => $delegate->name];
        static::initOrderRoom($room_data);
        // notify
        $notified_user = User::find($order->user_id);
        if ($notified_user) {
            dispatch(new DelegateAcceptOfferNotify($notified_user, $order, $delegate));
        }
        return $data;
    }

public static function delegateRefuseOrder(array $data)
    {
        $delegate = User::findOrFail($data['delegate_id']);
        $request  = $data['request'];
        if (!isset($request['order_id'])) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // find order
        $order             = Order::where('id', $request['order_id'])->whereNotIn('status',['closed','canceled'])->first();

if (!isset($order)) {
            $msg              = trans('order.A request cannot be assigned to this delegate');
            $data['fail_msg'] = $msg;
            return $data;
        }

if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

// assign order to delegate
        $order->update(['delegate_id' => $delegate->id, 'status' => 'canceled']);
        // notify
        $notified_user = User::find($order->user_id);
//        if ($notified_user) {
//            dispatch(new DelegateAcceptOfferNotify($notified_user, $order, $delegate));
//        }
        return $data;
    }

public static function delegateCreateOrderInvoice(array $data)
    {
        $delegate = auth('api')->user();
        $request = $data['request'];
        // find order
        $order = $delegate->delegateOrders()->where('id', $request['order_id'])->first();
        if (!$order) {
            $msg = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        $service_price=0.0;
        if (isset($request['service_name']) && isset($request['service_price']))
        {
            OrderServices::create([
                'order_id' => $request['order_id'],
                'name' => $request['service_name'],
                'price' => $request['service_price'],
            ]);
            $service_price+=$request['service_price'];
        }
        // order price
        $price = static::convert2english($request['price']);
        $price = (float)$price;
        // total_price
        $total_price = $order->delivery_price + $order->shipping_price + $price + $service_price;
        $added_value    = static::addedValue($total_price);
        $remain=$total_price-$order->deposit;
        // update order
        $order->update(['price' => $price, 'total_price' => $total_price,'added_value'=>$added_value,'remain'=>$remain, 'have_invoice' => 'true','invoice_accepted'=>'false']);
        // notify
        $notified_user = User::find($order->user_id);
        if ($notified_user) {
            dispatch(new DelegateCreateInvoiceNotify($notified_user, $order));
        }
    }

public static function UpdateInvoice(array $data)
    {
        $delegate = auth('api')->user();
        $request = $data['request'];
        // find order
        $order = $delegate->delegateOrders()->where('id', $request['order_id'])->first();
        if (!$order) {
            $msg = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        $service_price=0.0;
        if (isset($request['service_name']) && isset($request['service_price']))
        {
            OrderServices::create([
                'order_id' => $request['order_id'],
                'name' => $request['service_name'],
                'price' => $request['service_price'],
            ]);
            $service_price+=$request['service_price'];
        }
        // order price
        $price = static::convert2english($request['price']);
        $price = (float)$price;
        // total_price
        $total_price = $order->delivery_price + $order->shipping_price + $price + $service_price;
        $added_value    = static::addedValue($total_price);
        $remain=$total_price-$order->deposit;
        // update order
        $order->update(['price' => $price, 'total_price' => $total_price,'added_value'=>$added_value,'remain'=>$remain, 'have_invoice' => 'true','invoice_accepted'=>'false']);
        // notify
        $notified_user = User::find($order->user_id);
        if ($notified_user) {
            dispatch(new DelegateCreateInvoiceNotify($notified_user, $order));
        }
    }

public static function delegateIntransitOrder(array $data)
    {
        $delegate = auth('api')->user();
        // dd($delegate);
        $request  = $data['request'];
        // dd($delegate->delegateOrders);
        $order    = $delegate->delegateOrders()->where('id', $request['order_id'])->first();
        if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

// if ($request['delivery_status'] == 'delivering' && $order->type == 'special_request' && $order->delivery_status != 'accepted') {
        //     $msg              = trans('order.wait_store_prepared');
        //     $data['fail_msg'] = $msg;
        //     return $data;
        // }

$order->delivery_status = $request['delivery_status'];
        $order->status = 'inprogress';
        $order->type = $order->type;
        $order->update();
        // notify
        $notified_user = User::find($order->user_id);
        if ($notified_user) {
            dispatch(new OrderIntransitNotify($notified_user, $order, $request['delivery_status']));
        }
    }

public static function makeDeliveryOffer(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        $order   = Order::where('status', 'open')->where('id', $request['order_id'])->first();
        if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

//check if delegate withdraw this order before
        if ($user->withdrawReasons()->where('order_id', $order->id)->first()) {
            $msg              = trans('order.you_withdraw_this_order');
            $data['fail_msg'] = $msg;
            return $data;
        }

// delete previous offers
        if($user->deliveryOffers()->where('order_id', $request['order_id'])->where('status','new')->first()){
               $msg              = trans('order.you_have_offer');
            $data['fail_msg'] = $msg;
            return $data;
        }
        
        $setting_price = Setting::all()->pluck('value', 'key');
        $min_price     = $setting_price['min_expected_price'];
        $max_price     = $setting_price['max_expected_price'];
        
        if($request['price'] < $min_price || $request['price'] > $max_price){
            $msg              = trans('apis.price_must_between_max_min_price',['min_price'=>$min_price,'max_price'=>$max_price]);
            $data['fail_msg'] = $msg;
            return $data;
        }
        // $user->deliveryOffers()->where('order_id', $request['order_id'])->delete();
        // create new offer
        DeliveryOffer::create(['price' => $request['price'], 'user_id' => $user->id, 'order_id' => $request['order_id']]);
        // notify
        $notified_user = User::find($order->user_id);
        if ($notified_user) {
            dispatch(new DelegateMakeOfferNotify($notified_user, $order));
        }
    }

public static function cancelDeliveryOffer(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // delivery offer
        $delivery_offer = DeliveryOffer::where('status', 'new')->where('id', $request['delivery_offer_id'])->first();
        if (!$delivery_offer) {
            $msg              = trans('order.offer_not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // order
        $order = $delivery_offer->order()->first();
        if (!$order || $order->status != 'open') {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // update delivery_offer
        $delivery_offer->status = 'rejected';
        $delivery_offer->save();
    }

public static function SubmitCode(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // delivery offer

// order
        $order = Order::find($request['order_id']);
        if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
       if($order->ref_code != $request['code']){
            $msg              = trans('order.code_not_correct');
            $data['fail_msg'] = $msg;
            return $data;
       }else{
           $order->update(['code_submitted'=>true]);
       }
    }

public static function userAcceptDeliveryOffer(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // delivery offer
        $delivery_offer = DeliveryOffer::with('order')->where('status', 'new')->find($request['delivery_offer_id']);
        if (!$delivery_offer) {
            $msg              = trans('order.offer_not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        // order
        $order = $delivery_offer->order()->first();
        if (!$order || $order->user_id != $user->id) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

// delegate
        $delegate = $delivery_offer->user;

// update delivery_offer
        $delivery_offer->status = 'accepted';
        $delivery_offer->save();

// reject other delivery_offers
        DeliveryOffer::where('id', '!=', $request['delivery_offer_id'])->update(['status' => 'rejected']);

$order->update(['delegate_id'=>$delivery_offer->user_id,'have_invoice'=>'true']);
//        if($request['payment_method']=='wallet' && $order->deposite=='true'){
//
//        if($user->wallet < $delivery_offer->deposit){
//            $msg = trans('order.walletHasNoEnouphCredit');
//            $data['fail_msg'] = $msg;
//            return $data;
//            }
//            $pass['order']=$order;
//            $data['offer']=$delivery_offer;
//            // static::payOrderDepositeWithWallet($pass);
//        }else{
//            $order->update(['payment_type' =>$request['payment_method']]);
//        }

// update order | assign order to delegate & calc delivery_price & app percentage & added_value and the new total price
        $discount       = 0;
        // $delivery_price = number_format($delivery_offer->price, 2, '.', '');
        // $app_percentage = static::appPercentage($delivery_price);
        // $added_value    = static::addedValue($app_percentage);
        // total_price

// $order->delivery_status     = 'accepted';

$app_percentage = static::appPercentage($delivery_offer->price);
        $added_value    = static::addedValue($delivery_offer->price);
        $total_price                = $delivery_offer->price + $added_value;
        $total_price                = number_format($total_price, 2, '.', '');
        $order->price               =$delivery_offer->price;
        $order->app_percentage      = $app_percentage;
        $order->added_value         = $added_value;
        $order->total_price         = $total_price - $delivery_offer->deposit;
        $order->update();

// $order->delivery_price      = $delivery_price;

// $order->total_price         = $total_price;
        // $order->delegate_acceptance = date('Y-m-d H:i:s');
        // $order->update();
        // create the room
        $room_data = ['userone_id' => $user->id, 'usertwo_id' => $delivery_offer->user_id, 'order_id' => $order->id, 'delegate_name' => $delegate->name];
        static::initOrderRoom($room_data);

// notify
        $notified_user = User::find($order->delegate_id);
        if ($notified_user) {
            dispatch(new UserAcceptOfferNotify($notified_user, $order));
        }
    }

public static function userRejectDeliveryOffer(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // delivery offer
        $delivery_offer = DeliveryOffer::where('status', 'new')->where('id', $request['delivery_offer_id'])->first();
        if (!$delivery_offer) {
            $msg              = trans('order.offer_not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

// order
        $order = $delivery_offer->order()->first();
        if (!$order || $order->user_id != $user->id || $order->status != 'open') {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

// delegate
        $delegate = $delivery_offer->user;

// update delivery_offer
        $delivery_offer->status = 'rejected';
        $delivery_offer->save();
        // notify
        //        $notified_user = User::find($order->delegate_id);
        if ($delegate) {
            dispatch(new UserRejectOfferNotify($delegate, $order));
        }
    }

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 userAcceptInvoice(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // find order
        $order = $user->userOrders()->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;
//        }

if($user->wallet < $order->total_price){
            $msg = trans('order.walletHasNoEnouphCredit');
            $data['fail_msg'] = $msg;
            return $data;
        }

$order->update(['payment_type' => $request['payment_method'],'invoice_accepted'=>'true']);
        if($request['payment_method']=='wallet'){
            $pass['order']=$order;
            static::payOrderWithWallet($pass);
        }else{
            $order->update(['payment_status' => 'true', 'payment_type' =>$request['payment_method']]);
        }

$notified_user = User::find($order->delegate_id);
        if ($notified_user) {
            dispatch(new AcceptInvoiceNotify($notified_user, $order));
        }

}

public static function confirmPayment(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // find order
        $order = $user->delegateOrders()->where('id', $request['order_id'])->first();
        if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
        $order->update(['payment_confirmed' =>true]);
    }

public static function userRefuseInvoice(array $data)
    {
        $request = $data['request'];
        $user    = auth('api')->user();
        // find order
        $order = $user->userOrders()->where('id', $request['order_id'])->first();
        if (!$order) {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }
             $order->update(['invoice_accepted'=>'refused','have_invoice'=>'false']);

// notify
        $notified_user = User::find($order->delegate_id);
        if ($notified_user) {
            dispatch(new RefuseInvoiceNotify($notified_user, $order));
        }
    }

public static function delegateFinishOrder(array $data)
    {
        $order = $data['order'];
        // update order
        $order->update(['status' => 'finished','delivery_status' => 'delivered']);
           if ($order) {
            WaitingSettlementOrder::create([
                'order_id' => $order->id,
                'amount' => $order->price - $order->app_percentage,
                'userable_id' => $order->delegate_id,
                'userable_type' => 'App\\Models\\User',
            ]);
        }
         //notify
            $notified_user = User::find($order->user_id);
            if ($notified_user) {
                dispatch(new DelegateFinishOrder($notified_user, $order, $order->delegate));
            }

}

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();
        }

if($order){
            WaitingSettlementOrder::create([
                'order_id'=>$order->id,
                'amount'=>$order->price - $order->app_percentage,
                'userable_id' => $order->delegate_id,
                'userable_type' => 'App\\Models\\User',
            ]);
        }

// 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;
            $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']);
        $room = $order->rooms()->where('status', 'open')->orderBy('created_at', 'desc')->first();
        if ($room) {
            $room->update(['status' => 'finished']);
        }
        //notify
            $notified_user = User::find($order->delegate_id);
            if ($notified_user) {
                dispatch(new UserFinishOrder($notified_user, $order, $order->user));
            }

}

public static function cancelOrder(array $data)
    {
        $order  = $data['order'];

$date1 = Carbon::createFromDate($order->deliver_date); // start date
        $date2 = Carbon::createFromDate(now()); // end date
        $diff = $date1->diffInHours($date2);
        if($order->is_scheduled == 1 && $diff < 24){
            $msg              = trans('order.you_cannot_cancel');
            $data['fail_msg'] = $msg;
            return $data;
        }
        $order->update(['status' => 'closed','close_reason'=>$data['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 withdrawOrder(array $data)
    {
        $order  = $data['order'];
//        $reason = $data['reason'];
//        if ($order->payment_status == 'true' || $order->have_invoice == 'true') {
//            $msg              = trans('order.you_cannot_withdraw');
//            $data['fail_msg'] = $msg;
//            return $data;
//        }
        // update order
//        $order->update(['status' => 'open', 'delivery_status' => 'pending', 'delegate_id' => null]);
        WithdrawReason::create([ 'user_id' => auth('api')->user()->id, 'order_id' => $order->id]);
//        $notified_user = User::find($order['user_id']);
//        if ($notified_user) {
//            dispatch(new DelegateWithdrawNotify($notified_user, $order));
//        }
    }

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->delegate_id);
        $pay_type      = 'wallet';
        if ($notified_user) {
            dispatch(new DelegatePayWithWallet($notified_user, $order));
        }
    }

public  function payOrderDepositeWithWallet(array $data)
    {
        $request = $data;
        $order = $data['order'];
        $user  = $order->user;
        // update order
        if($request['payment_type']=='wallet'){
              $notified_user = User::find($order->delegate_id);
                $pay_type      = 'wallet';
                if ($notified_user) {
                    dispatch(new DelegatePayWithWallet($notified_user, $order));
                }
        $user->wallet -= $order->total_price;
        $user->update();
        }
        $order->update(['payment_type' =>$request['payment_type'],'payment_status'=>true]);
        //notify

}

public static function storeAcceptOrder(array $data)
    {

$order = $data['order'];
        $user  = $data['user'];
        if ($order['status'] == 'closed') {
            $msg              = trans('order.not_available');
            $data['fail_msg'] = $msg;
            return $data;
        }

// update order
        $order->update(['store_status' => 'accepted']);

//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
        $order->update(['store_status' => 'rejected', 'status' => 'closed']);
        //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', 'type' => $order->type]);
        //notify
        $notified_user = $order->delegate;
        dispatch(new StoreDoneOrderNotify($notified_user, $order));
        //notify
        $notified_user = $order->user;
        dispatch(new StoreDoneOrderNotify($notified_user, $order));
    }

public static function directDistance($latitudeFrom, $longitudeFrom, $latitudeTo, $longitudeTo)
    {
        $earthRadius = 6371000;
        // convert from degrees to radians
        $latFrom = deg2rad($latitudeFrom);
        $lonFrom = deg2rad($longitudeFrom);
        $latTo   = deg2rad($latitudeTo);
        $lonTo   = deg2rad($longitudeTo);

Back to File Manager