wticreatorstudio/Modules/Subscription/Http/Controllers/SubscriptionPlansController.php

<?php

namespace Modules\Subscription\Http\Controllers;

use App\Models\Cart;
use App\Repositories\CartRepository;
use App\Services\CheckoutService;
use Modules\Subscription\Rules\PhoneFormat;
use Brian2694\Toastr\Facades\Toastr;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Modules\Subscription\Entities\AmazeSubscription;
use Modules\Subscription\Entities\SubscriptionSetting;
use Modules\PaymentGateway\Http\Controllers\StripeController;
use Modules\Account\Repositories\TransactionRepository;
use Modules\Account\Entities\Transaction;
use Modules\FrontendCMS\Entities\SubsciptionPaymentInfo;
use App\Traits\Accounts;
use Carbon\Carbon;
use Exception;
use Modules\UserActivityLog\Traits\LogActivity;
use Stripe;
use Illuminate\Auth\Events\Registered;
use Modules\Subscription\Entities\SellerSubscription;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\File;
use Modules\Subscription\Entities\CustomerSubscription;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
use Modules\PaymentGateway\Services\PaymentGatewayService;
use Modules\Product\Entities\Product;
use Modules\Seller\Entities\SellerProduct;
use Modules\Subscription\Entities\SubscriptionProductMeta;
use Modules\Subscription\Repositories\SubscriptionPlansRepository;
use Modules\Subscription\Repositories\SubscriptionPlanPricesRepository;
use Modules\Subscription\Rules\ZipCodeDeliverability;
use Modules\Subscription\Services\AugmentationService;
use Illuminate\Support\Facades\Session;
use Modules\Account\Entities\ChartOfAccount;
use Modules\Shipping\Entities\ShippingMethod;
use Modules\Subscription\Entities\SubscriptionPlan;

class SubscriptionPlansController extends Controller
{
    use Accounts;

    private $subscriptionPlansRepository;
    private $stripePayment;

    public function __construct()
    {

        $this->subscriptionPlansRepository = new SubscriptionPlansRepository();
        $this->subscriptionPlanPricesRepository = new SubscriptionPlanPricesRepository();
        $credential = getPaymentInfoViaSellerId(1, 4);
        $this->stripePayment = new \Stripe\StripeClient([
          "api_key" => @$credential->perameter_3,
          "stripe_version" => "2022-11-15"
        ]);
    }

    public function index()
    {
        new AugmentationService();
        return view('subscription::plan.index');
    }

    public function data()
    {
        try {
            $setting = SubscriptionSetting::getData();
            $plans = $this->subscriptionPlansRepository->getAll();
            return response()->json([
                'plans' => $plans->load('prices'),
                'setting' => $setting
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'message' => 'An error occurred.'
            ], 500);
        }
    }

    
    public function store(Request $request)
    {
        $request->validate([
            'title' => 'required',
            'image' => 'required|image',
            'discount' => 'required'
        ]);

        try {
            
            $this->subscriptionPlansRepository->create($request);
            
            return response()->json([
                'message' => 'Plan has been successfully saved.'
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function update(Request $request)
    {
        $request->validate([
            'discount' => 'required'
        ]);

        try {

            $ret = $this->subscriptionPlansRepository->update($request);

            if ($ret) {
                return response()->json([
                    'message' => "Plan has been successfully updated."
                ]);
            }
            else {
                return response()->json([
                    'message' => 'Failed to update plan. Plan not found.'
                ], 500);
            }
        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function popular(Request $request)
    {

        try {

            $plan = SubscriptionPlan::find($request->id);
            if ($plan) {

                SubscriptionPlan::query()->update(['popular' => 0]);

                $plan->popular = 1;
                $plan->save();

                return response()->json([
                    'message' => "Plan has been set as popular."
                ]);
            }

            return response()->json([
                'message' => 'Failed to set as popular. Plan not found.'
            ], 500);

        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    }

    public function delete(Request $request)
    {
        try {

            $ret = $this->subscriptionPlansRepository->delete($request);

            if ($ret === true) {
                return response()->json([
                    'message' => 'Plan has been successfully deleted.'
                ]);
            }
            else {
                if ($ret == 'in_use') {
                    return response()->json([
                        'message' => 'Unable to delete plan. Plan is in use.'
                    ], 403);
                }
                else {
                    return response()->json([
                        'message' => 'Failed to delete plan. Plan not found.'
                    ], 500);
                }
            }
        } 
        catch (\Exception $e) {
            return response()->json([
                'message' => 'An error occurred. Failed to delete plan.'
            ], 500);
        }
    }

    public function changePlanPosition(Request $request)
    {
        $ids = $request->get('ids');

        if (count($ids) != 0) {
            foreach ($ids as $key => $id) {
                $plan = SubscriptionPlan::find($id);
                if ($plan) {
                    $plan->order = $key + 1;
                    $plan->save();
                }
            }
        }

        return true;
    }  

    public function priceStore(Request $request)
    {
        $request->validate([
            'subscription_plan_id' => 'required|exists:subscription_plans,id',
            'price' => 'required',
            'total_credits' => 'required',
            'per_month_credits' => 'required',
            'payment' => 'required',
            'billing_type' => 'required'
        ]);

        try {

            $plan = SubscriptionPlan::find($request->subscription_plan_id);
            if($plan){
                $this->subscriptionPlanPricesRepository->create($plan,$request);
                return response()->json([
                    'message' => 'Price has been successfully saved.'
                ]);
            } else {
                return response()->json([
                    'message' => 'Subscription Plan not found.'
                ], 404);
            }

            
        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    } 

    public function priceUpdate(Request $request)
    {
        $request->validate([
            'price' => 'required',
            'total_credits' => 'required',
            'per_month_credits' => 'required',
            'payment' => 'required',
            'billing_type' => 'required'
        ]);

        try {

            $response = $this->subscriptionPlanPricesRepository->update($request);

            if ($response) {
                return response()->json([
                    'message' => "Plan has been successfully updated."
                ]);
            }
            else {
                return response()->json([
                    'message' => 'Failed to update plan. Plan not found.'
                ], 500);
            }
        } catch (\Exception $e) {
            return response()->json([
                'message' => $e->getMessage()
            ], 500);
        }
    } 

    public function priceDelete(Request $request)
    {
        try {

            $response = $this->subscriptionPlanPricesRepository->delete($request->id);

            if ($response === true) {
                return response()->json([
                    'message' => 'Price has been successfully deleted.'
                ]);
            } else {
                return response()->json([
                    'message' => 'Failed to delete price. Price not found.'
                ], 500);
            }
        } 
        catch (\Exception $e) {
            return response()->json([
                'message' =>  $e->getMessage()
            ], 500);
        }
    } 

    private function getCredential(){
        $url = explode('?',url()->previous());
        if(isset($url[0]) && $url[0] == url('/checkout')){
            $is_checkout = true;
        }else{
            $is_checkout = false;
        }
        if(session()->has('order_payment') && app('general_setting')->seller_wise_payment && session()->has('seller_for_checkout') && $is_checkout){
            $credential = getPaymentInfoViaSellerId(session()->get('seller_for_checkout'), 4);
        }else{
            $credential = getPaymentInfoViaSellerId(1, 4);
        }
        return $credential;
    }
}