One Hat Cyber Team

View File Name : SystemController.php

<?php

namespace App\Http\Controllers;

use App\Models\EmailTemplate;
use App\Mail\EmailTest;
use App\Models\Utility;
use App\Models\Setting;
use App\Models\Webhook;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\File;

use Artisan;

class SystemController extends Controller
{
    public function index()
    {
        if (Auth::user()->can('Store Settings')) {
            $settings  = Utility::settings();
         
            $languages = Utility::languages();
            $EmailTemplates = EmailTemplate::all();
            $admin_payment_setting = Utility::getAdminPaymentSetting();
            $webhooks = Webhook::where('created_by', \Auth::user()->id)->get();
            
            return view('settings.index', compact('settings', 'languages', 'admin_payment_setting','EmailTemplates','webhooks'));
        } else {
            return redirect()->back()->with('error', __('Permission denied.'));
        }
    }

    public function store(Request $request)
    {
        if (\Auth::user()->can('Store Settings')) {
            if (\Auth::user()->isSuperAdmin()) {

                if($request->logo_dark)
                {
                    $request->validate(
                        [
                            'logo_dark' => 'image',
                        ]
                    );
                    $logoName = 'logo-dark.png';
                    $dir = 'uploads/logo/';
                    $validation =[
                        'mimes:'.'png',
                        'max:'.'20480',
                    ];

                    $path = Utility::upload_file($request,'logo_dark',$logoName,$dir,$validation);
                    if($path['flag'] == 1){
                        $logo_dark = $path['url'];
                    }else{
                        return redirect()->back()->with('error', __($path['msg']));
                    }

                }

                if($request->logo_light)
                {
                    $request->validate(
                        [
                            'logo_light' => 'image',
                        ]
                    );
                    $lightlogoName = 'logo-light.png';


                    $dir = 'uploads/logo/';
                    $validation =[
                        'mimes:'.'png',
                        'max:'.'20480',
                    ];

                    $path = Utility::upload_file($request,'logo_light',$lightlogoName,$dir,$validation);
                    if($path['flag'] == 1){
                        $logo_light = $path['url'];
                    }else{
                        return redirect()->back()->with('error', __($path['msg']));
                    }
                }

                if($request->favicon)
                {
                    $request->validate(
                        [
                            'favicon' => 'image',
                        ]
                    );
                    $favicon = 'favicon.png';


                    $dir = 'uploads/logo/';
                    $validation =[
                        'mimes:'.'png',
                        'max:'.'20480',
                    ];

                    $path = Utility::upload_file($request,'favicon',$favicon,$dir,$validation);
                    if($path['flag'] == 1){
                        $favicon = $path['url'];
                    }else{
                        return redirect()->back()->with('error', __($path['msg']));
                    }

                }

                $rules = [
                    // 'app_name' => 'required|string|max:50',
                    'default_language' => 'required|string|max:50',
                    // 'footer_text' => 'required|string|max:50',
                ];
    
                $request->validate($rules);
    
                $arrEnv = [
                    // 'APP_NAME' => $request->app_name,
                    'DEFAULT_LANG' => $request->default_language,
                    // 'FOOTER_TEXT' => $request->footer_text,
                    // 'DISPLAY_LANDING' => $request->display_landing ?? 'off',
                ];
    
                Utility::setEnvironmentValue($arrEnv);


                if (!empty($request->color) || !empty($request->cust_theme_bg) || !empty($request->email_verification) || !empty($request->cust_darklayout) || !empty($request->SITE_RTL) || !empty($request->gdpr_cookie) || !empty($request->disable_signup_button)) {
                    $post1 = $request->all();
                    if (!isset($request->cust_theme_bg)) {
                        $post1['cust_theme_bg'] = 'off';
                    }

                    if (!isset($request->cust_darklayout)) {
                        $post1['cust_darklayout'] = 'off';
                    }

                    if (!isset($request->gdpr_cookie)) {
                        $post1['gdpr_cookie'] = 'off';
                    }
                    if (!isset($request->display_landing)) {
                        $post1['display_landing'] = 'off';
                    }

                    if (!isset($request->email_verification)) {

                        $post1['email_verification'] = 'off';
                    }

                    if (!isset($request->footer_text)) {

                        $post1['footer_text'] = '';
                    }

                    if (!isset($request->app_name)) {
                        $post1['app_name'] = '';
                    }

                    // $post1['cookie_text'] = $request->cookie_text;

                    if (!isset($request->disable_signup_button)) {
                        $post1['disable_signup_button'] = 'off';
                    }

                    $post1['SITE_RTL'] = (!empty($request->SITE_RTL)) ? 'on' : 'off';

                    unset($post1['_token'], $post1['logo_dark'], $post1['logo_light'], $post1['favicon']);
                    $settings = Utility::settings();
                    foreach ($post1 as $key => $data) {
                        if (in_array($key, array_keys($settings))) {
                            \DB::insert(
                                'insert into settings (`value`, `name`,`created_by`) values (?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ',
                                [
                                    $data,
                                    $key,
                                    \Auth::user()->getCreatedBy(),
                                ]
                            );
                        }
                    }
                }
            } else {

                $user = \Auth::user();

                if($request->company_logo_dark)
                {
                    $request->validate(
                        [
                            'company_logo_dark' => 'image|mimes:png|max:20480',
                        ]
                    );
                    
                    //storage limit
                    $setting = Setting::where('created_by',\Auth::user()->creatorId())->where('name','company_logo_dark')->first();
                    if( $setting != null ){
                    	$file_path = 'uploads/logo/'.$setting->value;   // old image 
                    }
                    $image_size = $request->file('company_logo_dark')->getSize();
                    // dd($image_size);
                    $result = Utility::updateStorageLimit(\Auth::user()->creatorId(), $image_size);

                    if($result==1) 
                    {
			if( isset($file_path) ){
                        	Utility::changeStorageLimit(\Auth::user()->creatorId(), $file_path);
                        }

                        $logoName     = $user->id . '-logo-dark.png';
                        $dir = 'uploads/logo/';
                        $validation =[
                            'mimes:'.'png',
                            'max:'.'20480',
                        ];

                        $path = Utility::upload_file($request,'company_logo_dark',$logoName,$dir,$validation);
                        // dd($path);
                    }
                        if($path['flag'] == 1){
                            $company_logo_dark = $path['url'];


                            DB::table('settings')
                                ->updateOrInsert(
                                    ['name' => 'company_logo_dark', 'created_by' => \Auth::user()->creatorId()],
                                    ['name' => 'company_logo_dark', 'value'=> $logoName, 'created_by' => \Auth::user()->creatorId()]
                                );
                                
                                
                                
                        }else{
                            
                            return redirect()->back()->with('error', __($path['msg']));
                        }

                }

                if($request->company_logo_light)
                {

                    $request->validate(
                        [
                            'company_logo_light' => 'image|mimes:png|max:20480',
                        ]
                    );

                    //storage limit
                    $setting = Setting::where('created_by',\Auth::user()->creatorId())->where('name','company_logo_light')->first();
                    if( $setting != null ){
                    	$file_path = 'uploads/logo/'.$setting->value;   // old image 
                    }
                    $image_size = $request->file('company_logo_light')->getSize();
                    // dd($image_size);
                    $result = Utility::updateStorageLimit(\Auth::user()->creatorId(), $image_size);

                    if($result==1) 
                    {
			if( isset($file_path) ){
                        	Utility::changeStorageLimit(\Auth::user()->creatorId(), $file_path);
                        }

                        $logoName     = $user->id . '-logo-light.png';
                        $dir = 'uploads/logo/';
                        $validation =[
                            'mimes:'.'png',
                            'max:'.'20480',
                        ];

                        $path = Utility::upload_file($request,'company_logo_light',$logoName,$dir,$validation);


                        if($path['flag'] == 1){
                            $company_logo_light = $path['url'];

                            DB::table('settings')
                            ->updateOrInsert(
                                ['name' => 'company_logo_light', 'created_by' => \Auth::user()->creatorId()],
                                ['name' => 'company_logo_light', 'value'=> $logoName, 'created_by' => \Auth::user()->creatorId()]
                            );
                        }else{
                            return redirect()->back()->with('error', __($path['msg']));
                        }
                    }
                }
                if($request->company_favicon)
                {
                    $request->validate(
                        [
                            'company_favicon' => 'image|mimes:png|max:20480',
                        ]
                    );

                    //storage limit
                    $setting = Setting::where('created_by',\Auth::user()->creatorId())->where('name','company_favicon')->first();
                    if( $setting != null ){
                    	$file_path = 'uploads/logo/'.$setting->value;   // old image 
                    }
                    $image_size = $request->file('company_favicon')->getSize();
                    // dd($image_size);
                    $result = Utility::updateStorageLimit(\Auth::user()->creatorId(), $image_size);

                    if($result==1) 
                    {
			 if( isset($file_path) ){
                        	Utility::changeStorageLimit(\Auth::user()->creatorId(), $file_path);
                        }

                        $favicon = $user->id . '_favicon.png';
                        $dir = 'uploads/logo/';
                        $validation =[
                            'mimes:'.'png',
                            'max:'.'20480',
                        ];

                        $path = Utility::upload_file($request,'company_favicon',$favicon,$dir,$validation);


                        if($path['flag'] == 1){
                            $company_favicon = $path['url'];

                            DB::table('settings')
                            ->updateOrInsert(
                                ['name' => 'company_favicon', 'created_by' => \Auth::user()->creatorId()],
                                ['name' => 'company_favicon', 'value'=> $favicon, 'created_by' => \Auth::user()->creatorId()]
                            );
                        }else{
                            return redirect()->back()->with('error', __($path['msg']));
                        }
                    }
                }

                if (!empty($request->color) || !empty($request->cust_theme_bg) || !empty($request->cust_darklayout) || !empty($request->SITE_RTL)) {
                    $post = $request->all();
                    if (!isset($request->cust_theme_bg)) {
                        $post['cust_theme_bg'] = 'off';
                    }
                    if (!isset($request->cust_darklayout)) {
                        $post['cust_darklayout'] = 'off';
                    }

                    $post['SITE_RTL'] = (!empty($request->SITE_RTL)) ? 'on' : 'off';

                    unset($post['_token'], $post['company_logo_dark'], $post['company_logo_light'], $post['company_favicon']);
                    $settings = Utility::settings();
                    foreach ($post as $key => $data) {
                        if (in_array($key, array_keys($settings))) {
                            \DB::insert(
                                'insert into settings (`value`, `name`,`created_by`) values (?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ',
                                [
                                    $data,
                                    $key,
                                    \Auth::user()->getCreatedBy(),
                                ]
                            );
                        }
                    }
                }
                // return redirect()->back()->with('success', __('Settings updated successfully.'));
                return redirect()->back()->with('success', __('Settings updated successfully.'). ((isset($result) && $result!=1) ? '<br> <span class="text-danger">' . $result . '</span>' : ''));

            }
            // Artisan::call('config:cache');
            // Artisan::call('config:clear');

            return redirect()->back()->with('success', __('Settings updated successfully.'));
        } else {
            return redirect()->back()->with('error', __('Permission denied.'));
        }
    }

    public function saveGeneralSettings(Request $request)
    {
        if (Auth::user()->can('Store Settings')) {
            if (\Auth::user()->isSuperAdmin()) {
                $post = [];

                if ($request->has('low_product_stock_threshold')) {
                    $post['low_product_stock_threshold'] = $request->low_product_stock_threshold;
                }

                if (isset($post) && !empty($post) && count($post) > 0) {
                    $created_at = $updated_at = date('Y-m-d H:i:s');
                    foreach ($post as $key => $data) {
                        DB::insert(
                            'INSERT INTO settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `updated_at` = VALUES(`updated_at`) ',
                            [
                                $data,
                                $key,
                                Auth::user()->getCreatedBy(),
                                $created_at,
                                $updated_at,
                            ]
                        );
                    }
                }

                $validator = Validator::make(
                    $request->all(),
                    [
                        'mail_driver' => 'required|string|max:50',
                        'mail_host' => 'required|string|max:50',
                        'mail_port' => 'required|string|max:50',
                        'mail_username' => 'required|string|max:50',
                        'mail_password' => 'required|string|max:255',
                        'mail_encryption' => 'required|string|max:50',
                        'mail_from_address' => 'required|string|max:50',
                        'mail_from_name' => 'required|string|max:50',
                    ]
                );

                if ($validator->fails()) {
                    return redirect()->back()->with('error', $validator->errors()->first());
                }

                $env = [
                    'MAIL_DRIVER' => $request->mail_driver,
                    'MAIL_HOST' => $request->mail_host,
                    'MAIL_PORT' => $request->mail_port,
                    'MAIL_USERNAME' => $request->mail_username,
                    'MAIL_PASSWORD' => $request->mail_password,
                    'MAIL_ENCRYPTION' => $request->mail_encryption,
                    'MAIL_FROM_ADDRESS' => $request->mail_from_address,
                    'MAIL_FROM_NAME' => $request->mail_from_name,
                    'FOOTER_LINK_1' => $request->footer_link_1,
                    'FOOTER_LINK_2' => $request->footer_link_2,
                    'FOOTER_LINK_3' => $request->footer_link_3,
                    'FOOTER_VALUE_1' => $request->footer_value_1,
                    'FOOTER_VALUE_2' => $request->footer_value_1,
                    'FOOTER_VALUE_3' => $request->footer_value_1,
                ];

                Utility::setEnvironmentValue($env);
                //Artisan::call('config:cache');
                //Artisan::call('config:clear');
                return redirect()->back()->with('success', __('Settings updated successfully.'));
            
            } else{

                $validator = Validator::make(
                    $request->all(),
                    [
                        'mail_driver' => 'required|string|max:50',
                        'mail_host' => 'required|string|max:50',
                        'mail_port' => 'required|string|max:50',
                        'mail_username' => 'required|string|max:50',
                        'mail_password' => 'required|string|max:255',
                        'mail_encryption' => 'required|string|max:50',
                        'mail_from_address' => 'required|string|max:50',
                        'mail_from_name' => 'required|string|max:50',
                    ]
                );

                if ($validator->fails()) {
                    return redirect()->back()->with('error', $validator->errors()->first());
                }

                $env = [
                    'MAIL_DRIVER' => $request->mail_driver,
                    'MAIL_HOST' => $request->mail_host,
                    'MAIL_PORT' => $request->mail_port,
                    'MAIL_USERNAME' => $request->mail_username,
                    'MAIL_PASSWORD' => $request->mail_password,
                    'MAIL_ENCRYPTION' => $request->mail_encryption,
                    'MAIL_FROM_ADDRESS' => $request->mail_from_address,
                    'MAIL_FROM_NAME' => $request->mail_from_name,
                ];

                // Utility::setEnvironmentValue($env);
                if (isset($env) && !empty($env) && count($env) > 0) {
                    $created_at = $updated_at = date('Y-m-d H:i:s');
                    foreach ($env as $key => $data) {
                        DB::insert(
                            'INSERT INTO settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `updated_at` = VALUES(`updated_at`) ',
                            [
                                $data,
                                $key,
                                Auth::user()->getCreatedBy(),
                                $created_at,
                                $updated_at,
                            ]
                        );
                    }
                }

                return redirect()->back()->with('success', __('Settings updated successfully.'));
            }
            
        } else {
            return redirect()->back()->with('error', __('Permission denied.'));
        }
    }

    public function savePaymentSettings(Request $request)
    {
       
        if (Auth::user()->can('Store Settings')) {
            $stripe_status = $request->enable_stripe ?? 'off';
            $paypal_status = $request->enable_paypal ?? 'off';
 
            $validatorArray = [
                'currency' => 'required|string|max:10',
                'currency_symbol' => 'required|string|max:10',
            ];
            
            $validator = Validator::make(
                $request->all(),
                $validatorArray
            );
            if ($validator->fails()) {
                return redirect()->back()->with('error', $validator->errors()->first());
            }
            
            $arrEnv = [
                'CURRENCY_SYMBOL' => $request->currency_symbol,
                'CURRENCY' => $request->currency,
            ];
            Utility::setEnvironmentValue($arrEnv);
            
            self::adminPaymentSettings($request);
            
            return redirect()->back()->with('success', __('Settings updated successfully.'));
        } else {
            return redirect()->back()->with('error', __('Permission denied.'));
        }
    }
    
    public function adminPaymentSettings($request)
    {
        if (isset($request->currency_symbol) && isset($request->currency)) {
            $request->validate(
                    [
                    'currency' => 'required|string|max:10',
                    'currency_symbol' => 'required|string|max:10',
                    ]
                );

            $post['currency_symbol'] = $request->currency_symbol;
            $post['currency'] = $request->currency;

        } else {
            $post['currency_symbol'] = '$';
            $post['currency'] = 'USD';
        }

        if (isset($request->is_manually_enabled) && $request->is_manually_enabled == 'on') {
                
                $post['is_manually_enabled'] = $request->is_manually_enabled;

        } else {
            $post['is_manually_enabled'] = 'off';
        }

        if (isset($request->is_banktransfer_enabled) && $request->is_banktransfer_enabled == 'on') {
            
            $request->validate(
                [
                    'bank_details' => 'required|string|max:255',
                    ]
                );
                
                $post['is_banktransfer_enabled'] = $request->is_banktransfer_enabled;
                $post['bank_details']        = $request->bank_details;
        } else {
            $post['is_banktransfer_enabled'] = 'off';
        }

        if (isset($request->is_stripe_enabled) && $request->is_stripe_enabled == 'on') {
            
            $request->validate(
                [
                    'stripe_key' => 'required|string|max:255',
                    'stripe_secret' => 'required|string|max:255',
                    ]
                );
                
                $post['is_stripe_enabled'] = $request->is_stripe_enabled;
                $post['stripe_secret']     = $request->stripe_secret;
                $post['stripe_key']        = $request->stripe_key;
        } else {
            $post['is_stripe_enabled'] = 'off';
        }
            
        if (isset($request->is_paypal_enabled) && $request->is_paypal_enabled == 'on') {
          
            $request->validate(
                [
                    'paypal_mode' => 'required',
                    'paypal_client_id' => 'required',
                    'paypal_secret_key' => 'required',
                    ]
                );

                $post['is_paypal_enabled'] = $request->is_paypal_enabled;
                $post['paypal_mode']       = $request->paypal_mode;
                $post['paypal_client_id']  = $request->paypal_client_id;
                $post['paypal_secret_key'] = $request->paypal_secret_key;
        } else {
                $post['is_paypal_enabled'] = 'off';
        }
        
        if (isset($request->is_paystack_enabled) && $request->is_paystack_enabled == 'on') {
            
            $request->validate(
                [
                    'paystack_public_key' => 'required|string',
                    'paystack_secret_key' => 'required|string',
                ]
            );
            $post['is_paystack_enabled'] = $request->is_paystack_enabled;
            $post['paystack_public_key'] = $request->paystack_public_key;
            $post['paystack_secret_key'] = $request->paystack_secret_key;

            
        } else {
            $post['is_paystack_enabled'] = 'off';
        }
        
        if (isset($request->is_flutterwave_enabled) && $request->is_flutterwave_enabled == 'on') {
            $request->validate(
                [
                    'flutterwave_public_key' => 'required|string',
                    'flutterwave_secret_key' => 'required|string',
                ]
            );
            $post['is_flutterwave_enabled'] = $request->is_flutterwave_enabled;
            $post['flutterwave_public_key'] = $request->flutterwave_public_key;
            $post['flutterwave_secret_key'] = $request->flutterwave_secret_key;
        } else {
            $post['is_flutterwave_enabled'] = 'off';
        }
        
        if (isset($request->is_razorpay_enabled) && $request->is_razorpay_enabled == 'on') {
            $request->validate(
                [
                    'razorpay_public_key' => 'required|string',
                    'razorpay_secret_key' => 'required|string',
                ]
            );
            $post['is_razorpay_enabled'] = $request->is_razorpay_enabled;
            $post['razorpay_public_key'] = $request->razorpay_public_key;
            $post['razorpay_secret_key'] = $request->razorpay_secret_key;
        } else {
            $post['is_razorpay_enabled'] = 'off';
        }
      
        if (isset($request->is_mercado_enabled) && $request->is_mercado_enabled == 'on') {
            $request->validate(
                [
                    'mercado_access_token' => 'required|string',
                ]
            );
            $post['is_mercado_enabled'] = $request->is_mercado_enabled;
            $post['mercado_access_token']     = $request->mercado_access_token;
            $post['mercado_mode'] = $request->mercado_mode;
        } else {
            $post['is_mercado_enabled'] = 'off';
        }
       
        if (isset($request->is_paytm_enabled) && $request->is_paytm_enabled == 'on') {
            $request->validate(
                [
                    'paytm_mode' => 'required',
                    'paytm_merchant_id' => 'required|string',
                    'paytm_merchant_key' => 'required|string',
                    'paytm_industry_type' => 'required|string',
                ]
            );
            $post['is_paytm_enabled']    = $request->is_paytm_enabled;
            $post['paytm_mode']          = $request->paytm_mode;
            $post['paytm_merchant_id']   = $request->paytm_merchant_id;
            $post['paytm_merchant_key']  = $request->paytm_merchant_key;
            $post['paytm_industry_type'] = $request->paytm_industry_type;
           
        } else {
            $post['is_paytm_enabled'] = 'off';
        }
       
        if (isset($request->is_mollie_enabled) && $request->is_mollie_enabled == 'on') {
            $request->validate(
                [
                    'mollie_api_key' => 'required|string',
                    'mollie_profile_id' => 'required|string',
                    'mollie_partner_id' => 'required',
                ]
            );
            $post['is_mollie_enabled'] = $request->is_mollie_enabled;
            $post['mollie_api_key']    = $request->mollie_api_key;
            $post['mollie_profile_id'] = $request->mollie_profile_id;
            $post['mollie_partner_id'] = $request->mollie_partner_id;
        } else {
            $post['is_mollie_enabled'] = 'off';
        }
       
        if (isset($request->is_skrill_enabled) && $request->is_skrill_enabled == 'on') {
            $request->validate(
                [
                    'skrill_email' => 'required|email',
                ]
            );
            $post['is_skrill_enabled'] = $request->is_skrill_enabled;
            $post['skrill_email']      = $request->skrill_email;
        } else {
            $post['is_skrill_enabled'] = 'off';
        }
       
        if (isset($request->is_coingate_enabled) && $request->is_coingate_enabled == 'on') {
            $request->validate(
                [
                    'coingate_mode' => 'required|string',
                    'coingate_auth_token' => 'required|string',
                ]
            );

            $post['is_coingate_enabled'] = $request->is_coingate_enabled;
            $post['coingate_mode']       = $request->coingate_mode;
            $post['coingate_auth_token'] = $request->coingate_auth_token;
        } else {
            $post['is_coingate_enabled'] = 'off';
        }
       
        if (isset($request->is_paymentwall_enabled) && $request->is_paymentwall_enabled == 'on') {

            $request->validate(
                [
                    'paymentwall_public_key' => 'required|string',
                    'paymentwall_secret_key' => 'required|string',
                ]
            );
            $post['is_paymentwall_enabled'] = $request->is_paymentwall_enabled;
            $post['paymentwall_public_key'] = $request->paymentwall_public_key;
            $post['paymentwall_secret_key'] = $request->paymentwall_secret_key;
        } else {
            $post['is_paymentwall_enabled'] = 'off';
        }
        
        if (isset($request->is_toyyibpay_enabled) && $request->is_toyyibpay_enabled == 'on') {

            $request->validate(
                [
                    'toyyibpay_secret_key' => 'required|string',
                    'category_code' => 'required',
                ]
            );
            $post['is_toyyibpay_enabled'] = $request->is_toyyibpay_enabled;
            $post['toyyibpay_secret_key'] = $request->toyyibpay_secret_key;
            $post['category_code'] = $request->category_code;
        } else {
            $post['is_toyyibpay_enabled'] = 'off';
        }

        if (isset($request->is_payfast_enabled) && $request->is_payfast_enabled == 'on') {
            
            $request->validate(
                [
                    'payfast_mode' => 'required',
                    'payfast_merchant_id' => 'required',
                    'payfast_merchant_key' => 'required',
                    'payfast_signature' => 'required',
                ]
            );
            $post['is_payfast_enabled'] = $request->is_payfast_enabled;
            $post['payfast_merchant_id'] = $request->payfast_merchant_id;
            $post['payfast_merchant_key']       = $request->payfast_merchant_key;
            $post['payfast_signature'] = $request->payfast_signature;
            $post['payfast_mode'] = $request->payfast_mode;
        } else {
            $post['is_payfast_enabled'] = 'off';
        }

        if (isset($request->is_iyzipay_enabled) && $request->is_iyzipay_enabled == 'on') {
          
            $request->validate(
                [
                    'iyzipay_mode' => 'required',
                    'iyzipay_api_key' => 'required',
                    'iyzipay_secret_key' => 'required',
                    ]
                );

                $post['is_iyzipay_enabled'] = $request->is_iyzipay_enabled;
                $post['iyzipay_mode']       = $request->iyzipay_mode;
                $post['iyzipay_api_key']  = $request->iyzipay_api_key;
                $post['iyzipay_secret_key'] = $request->iyzipay_secret_key;
        } else {
                $post['is_iyzipay_enabled'] = 'off';
        }

        if (isset($request->is_sspay_enabled) && $request->is_sspay_enabled == 'on') {
          
            $request->validate(
                [
                    'sspay_category_code' => 'required',
                    'sspay_secret_key' => 'required',
                    ]
                );

                $post['is_sspay_enabled'] = $request->is_sspay_enabled;
                $post['sspay_category_code']  = $request->sspay_category_code;
                $post['sspay_secret_key'] = $request->sspay_secret_key;
        } else {
                $post['is_sspay_enabled'] = 'off';
        }

        if (isset($request->is_paytab_enabled) && $request->is_paytab_enabled == 'on') {
          
            $request->validate(
                [
                    'paytab_profile_id' => 'required',
                    'paytab_server_key' => 'required',
                    'paytab_region' => 'required',
                    ]
                );

                $post['is_paytab_enabled'] = $request->is_paytab_enabled;
                $post['paytab_profile_id']  = $request->paytab_profile_id;
                $post['paytab_server_key'] = $request->paytab_server_key;
                $post['paytab_region'] = $request->paytab_region;
        } else {
                $post['is_paytab_enabled'] = 'off';
        }

        if (isset($request->is_benefit_enabled) && $request->is_benefit_enabled == 'on') {
          
            $request->validate(
                [
                    'benefit_api_key' => 'required',
                    'benefit_secret_key' => 'required',
                    ]
                );

                $post['is_benefit_enabled'] = $request->is_benefit_enabled;
                $post['benefit_api_key']  = $request->benefit_api_key;
                $post['benefit_secret_key'] = $request->benefit_secret_key;
        } else {
                $post['is_benefit_enabled'] = 'off';
        }

        if (isset($request->is_cashfree_enabled) && $request->is_cashfree_enabled == 'on') {
          
            $request->validate(
                [
                    'cashfree_api_key' => 'required',
                    'cashfree_secret_key' => 'required',
                    ]
                );

                $post['is_cashfree_enabled'] = $request->is_cashfree_enabled;
                $post['cashfree_api_key']  = $request->cashfree_api_key;
                $post['cashfree_secret_key'] = $request->cashfree_secret_key;
        } else {
                $post['is_cashfree_enabled'] = 'off';
        }

        if (isset($request->is_aamarpay_enabled) && $request->is_aamarpay_enabled == 'on') {
          
            $request->validate(
                [
                    'aamarpay_store_id' => 'required',
                    'aamarpay_signature_key' => 'required',
                    'aamarpay_description' => 'required',
                    ]
                );

                $post['is_aamarpay_enabled'] = $request->is_aamarpay_enabled;
                $post['aamarpay_store_id']  = $request->aamarpay_store_id;
                $post['aamarpay_signature_key'] = $request->aamarpay_signature_key;
                $post['aamarpay_description'] = $request->aamarpay_description;
        } else {
                $post['is_aamarpay_enabled'] = 'off';
        }

        if (isset($request->is_paytr_enabled) && $request->is_paytr_enabled == 'on') {
          
            $request->validate(
                [
                    'paytr_merchant_id' => 'required',
                    'paytr_merchant_key' => 'required',
                    'paytr_merchant_salt' => 'required',
                    ]
                );

                $post['is_paytr_enabled'] = $request->is_paytr_enabled;
                $post['paytr_merchant_id']  = $request->paytr_merchant_id;
                $post['paytr_merchant_key'] = $request->paytr_merchant_key;
                $post['paytr_merchant_salt'] = $request->paytr_merchant_salt;
        } else {
                $post['is_paytr_enabled'] = 'off';
        }


        // dd($post);
        foreach ($post as $key => $data) {

            $arr = [
                $data,
                $key,
                \Auth::user()->id,
            ];
            \DB::insert(
                'insert into admin_payment_settings (`value`, `name`,`created_by`) values (?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ',
                $arr
            );
        }
    }

    // public function savePaymentSettings(Request $request)
    // {
    //     // dd($request->all());
    //     $userId = Auth::user()->id;
    //     $user = Auth::user();
    //     $created_by = $user->get_created_by();

    //     if(Auth::user()->type == 'super admin')
    //     {
    //         $request->validate(
    //             [
    //                 'currency' => 'required|string|max:255',
    //                 'currency_symbol' => 'required|string|max:255',
    //             ]
    //         );

    //         $arrEnv = [
    //             'CURRENCY_SYMBOL' => $request->currency_symbol,
    //             'CURRENCY' => $request->currency
    //         ];

    //         $request->user = \Auth::user()->id;

    //         // Artisan::call('config:cache');
    //         // Artisan::call('config:clear');

    //         Utility::setEnvironmentValue($arrEnv);
    //         $post = $request->all();
    //         unset($post['_token']);
    //         foreach($post as $key => $data)
    //         {
    //             \DB::insert(
    //                 'insert into admin_payment_settings (`value`, `name`,`created_by`,`created_at`,`updated_at`)
    //                 values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ', [
    //                                                         $data,
    //                                                         $key,
    //                                                         $request->user,
    //                                                         date('Y-m-d H:i:s'),
    //                                                         date('Y-m-d H:i:s'),
    //                                                                             ]
    //             );
    //         }

    //         self::adminPaymentSettings($request);

    //         return redirect()->back()->with('success', __('Payment setting successfully saved.'));
    //     }
    //     else
    //     {
    //         return redirect()->back()->with('error', __('Permission denied.'));
    //     }
    // }

    public function recaptchaSettingStore(Request $request)
    {
        $user = \Auth::user();
        $rules = [];

        if ($request->recaptcha_module == 'yes') {
            $rules['google_recaptcha_key'] = 'required|string|max:50';
            $rules['google_recaptcha_secret'] = 'required|string|max:50';
        }

        $validator = \Validator::make(
            $request->all(),
            $rules
        );
        if ($validator->fails()) {
            $messages = $validator->getMessageBag();

            return redirect()->back()->with('error', $messages->first());
        }

        $arrEnv = [
            'RECAPTCHA_MODULE' => $request->recaptcha_module ?? 'no',
            'NOCAPTCHA_SITEKEY' => $request->google_recaptcha_key,
            'NOCAPTCHA_SECRET' => $request->google_recaptcha_secret,
        ];

        if (Utility::setEnvironmentValue($arrEnv)) {
            return redirect()->back()->with('success', __('Recaptcha Settings updated successfully'));
        } else {
            return redirect()->back()->with('error', __('Something is wrong'));
        }
    }

    public function saveSystemSettings(Request $request)
    {
        $post = $request->all();
        unset($post['_token']);
        unset($post['company_email']);
        unset($post['company_email_from_name']);
        if ($request->has('system_settings') && $request->system_settings == 1) {
            unset($post['system_settings']);
        } else {
            $validator = Validator::make(
                $request->all(),
                [
                    'company_name' => 'required',
                    // 'company_email' => 'required',
                    // 'company_email_from_name' => 'required',
                ]
            );

            if ($validator->fails()) {
                return redirect()->back()->with('error', $validator->errors()->first());
            }
        }

        if(empty($post['vat_number']))
        {
            $post['vat_number']='';
        }

        $created_at = $updated_at = date('Y-m-d H:i:s');
      
        foreach ($post as $key => $data) {
            DB::insert(
                'INSERT INTO settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `updated_at` = VALUES(`updated_at`) ',
                [
                    $data,
                    $key,
                    Auth::user()->getCreatedBy(),
                    $created_at,
                    $updated_at,
                ]
            );
        }

        return redirect()->back()->with('success', __('Settings updated successfully.'));
    }

    public function saveTemplateSettings(Request $request)
    {
        $post = $request->all();
        unset($post['_token']);

        if (isset($post['purchase_invoice_template']) && (!isset($post['purchase_invoice_color']) || empty($post['purchase_invoice_color']))) {
            $post['purchase_invoice_color'] = "ffffff";
        }
        if ($request->purchase_logo) {
            $userDetail = \Auth::user();
            $user = User::findOrFail($userDetail['id']);
            $this->validate(
                $request, [
                            'purchase_logo' => 'required',
                        ]
            );
            if($request->hasFile('purchase_logo'))
            {
                $filenameWithExt = $request->file('purchase_logo')->getClientOriginalName();
                $filename        = pathinfo($filenameWithExt, PATHINFO_FILENAME);
                $extension       = $request->file('purchase_logo')->getClientOriginalExtension();
                $fileNameToStore = $user->id . '_' . 'purchase_logo' . '.' . $extension;
                $settings = Utility::settings();//Utility::getStorageSetting();
                $dir        = 'uploads/invoice_logo';

                $image_path = $dir . $settings['purchase_logo'];
                if(File::exists($image_path))
                {
                    File::delete($image_path);
                }

                $path = Utility::upload_file($request,'purchase_logo',$fileNameToStore,$dir,[]);
                // dd($path);
                if($path['flag'] == 1){
                    $url = $path['url'];
                }else{
                    return redirect()->back()->with('error', __($path['msg']));
                }
            }
            if(!empty($request->purchase_logo))
            {
                $post['purchase_logo'] = $fileNameToStore;
            }
        }

        if (isset($post['sale_invoice_template']) && (!isset($post['sale_invoice_color']) || empty($post['sale_invoice_color']))) {
            $post['sale_invoice_color'] = "ffffff";
        }
        if ($request->sale_logo) {
            $userDetail = \Auth::user();
            $user = User::findOrFail($userDetail['id']);
            $this->validate(
                $request, [
                            'sale_logo' => 'required',
                        ]
            );
            if($request->hasFile('sale_logo'))
            {
                $filenameWithExt = $request->file('sale_logo')->getClientOriginalName();
                $filename        = pathinfo($filenameWithExt, PATHINFO_FILENAME);
                $extension       = $request->file('sale_logo')->getClientOriginalExtension();
                $fileNameToStore = $user->id . '_' . 'sale_logo' . '.' . $extension;
                $settings = Utility::settings();
                $dir        = 'uploads/invoice_logo';

                $image_path = $dir . $settings['sale_logo'];
                if(File::exists($image_path))
                {
                    File::delete($image_path);
                }

                $path = Utility::upload_file($request,'sale_logo',$fileNameToStore,$dir,[]);
                // dd($path);
                if($path['flag'] == 1){
                    $url = $path['url'];
                }else{
                    return redirect()->back()->with('error', __($path['msg']));
                }
            }
            if(!empty($request->sale_logo))
            {
                $post['sale_logo'] = $fileNameToStore;
            }
        }

        if (isset($post['quotation_invoice_template']) && (!isset($post['quotation_invoice_color']) || empty($post['quotation_invoice_color']))) {
            $post['quotation_invoice_color'] = "ffffff";
        }
        if ($request->quotation_logo) {
            $userDetail = \Auth::user();
            $user = User::findOrFail($userDetail['id']);
            $this->validate(
                $request, [
                            'quotation_logo' => 'required',
                        ]
            );
            if($request->hasFile('quotation_logo'))
            {
                $filenameWithExt = $request->file('quotation_logo')->getClientOriginalName();
                $filename        = pathinfo($filenameWithExt, PATHINFO_FILENAME);
                $extension       = $request->file('quotation_logo')->getClientOriginalExtension();
                $fileNameToStore = $user->id . '_' . 'quotation_logo' . '.' . $extension;
                $settings = Utility::settings();
                $dir        = 'uploads/invoice_logo';

                $image_path = $dir . $settings['quotation_logo'];
                if(File::exists($image_path))
                {
                    File::delete($image_path);
                }

                $path = Utility::upload_file($request,'quotation_logo',$fileNameToStore,$dir,[]);
                // dd($path);
                if($path['flag'] == 1){
                    $url = $path['url'];
                }else{
                    return redirect()->back()->with('error', __($path['msg']));
                }
            }
            if(!empty($request->quotation_logo))
            {
                $post['quotation_logo'] = $fileNameToStore;
            }
        }

        $created_at = $updated_at = date('Y-m-d H:i:s');

        foreach ($post as $key => $data) {
            DB::insert(
                'INSERT INTO settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `updated_at` = VALUES(`updated_at`) ',
                [
                    $data,
                    $key,
                    Auth::user()->getCreatedBy(),
                    $created_at,
                    $updated_at,
                ]
            );
        }

        if (isset($post['purchase_invoice_template'])) {
            return redirect()->back()->with('success', __('Purchase Invoice Setting updated successfully.'));
        }

        if (isset($post['sale_invoice_template'])) {
            return redirect()->back()->with('success', __('Sale Invoice Setting updated successfully'));
        }

        if (isset($post['quotation_invoice_template'])) {
            return redirect()->back()->with('success', __('Quotation Invoice Setting updated successfully'));
        }
    }

    public function saveInvoiceFooterSettings(Request $request)
    {
        $post = $request->all();
        unset($post['_token']);

        $created_at = $updated_at = date('Y-m-d H:i:s');

        foreach ($post as $key => $data) {
            DB::insert(
                'INSERT INTO settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `updated_at` = VALUES(`updated_at`) ',
                [
                    $data,
                    $key,
                    Auth::user()->getCreatedBy(),
                    $created_at,
                    $updated_at,
                ]
            );
        }

        return redirect()->back()->with('success', __('Invoice Footer Setting updated successfully'));
    }

    public function testEmail(Request $request)
    {
        $data                      = [];
        $data['mail_driver']       = $request->mail_driver;
        $data['mail_host']         = $request->mail_host;
        $data['mail_port']         = $request->mail_port;
        $data['mail_username']     = $request->mail_username;
        $data['mail_password']     = $request->mail_password;
        $data['mail_encryption']   = $request->mail_encryption;
        $data['mail_from_address'] = $request->mail_from_address;
        $data['mail_from_name']    = $request->mail_from_name;

        return view('users.test_email', compact('data'));
    }

    public function testEmailSend(Request $request)
    {
        $validator = Validator::make(
            $request->all(),
            [
                'email' => 'required|email',
                'mail_driver' => 'required',
                'mail_host' => 'required',
                'mail_port' => 'required',
                'mail_username' => 'required',
                'mail_password' => 'required',
                'mail_from_address' => 'required',
                'mail_from_name' => 'required',
            ]
        );

        if ($validator->fails()) {

            $messages = $validator->getMessageBag();
            // return redirect()->back()->with('error', $messages->first());
            return response()->json(
                [
                    'is_success' => false,
                    'message' => $messages->first(),
                ]
            );
        }
        //    dd($request->all());
        try {
            config(
                [
                    'mail.driver' => $request->mail_driver,
                    'mail.host' => $request->mail_host,
                    'mail.port' => $request->mail_port,
                    'mail.encryption' => $request->mail_encryption,
                    'mail.username' => $request->mail_username,
                    'mail.password' => $request->mail_password,
                    'mail.from.address' => $request->mail_from_address,
                    'mail.from.name' => $request->mail_from_name,
                ]
            );
            // dd(config('mail'),$request->email);
            Mail::to($request->email)->send(new EmailTest());

        } catch (\Exception $e) {

            $smtp_error = __('E-Mail has been not sent due to SMTP configuration');


            return response()->json(
                [
                    'is_success' => false,
                    'message' => $smtp_error,
                ]
            );
        }

        return response()->json(
            [
                'is_success' => true,
                'message' => __('Email send Successfully'),
            ]
        );
    }

    

    public function storageSettingStore(Request $request)
    {

        if(isset($request->storage_setting) && $request->storage_setting == 'local')
        {

            $request->validate(
                [

                    'local_storage_validation' => 'required',
                    'local_storage_max_upload_size' => 'required',
                ]
            );

            $post['storage_setting'] = $request->storage_setting;
            $local_storage_validation = implode(',', $request->local_storage_validation);
            $post['local_storage_validation'] = $local_storage_validation;
            $post['local_storage_max_upload_size'] = $request->local_storage_max_upload_size;

        }

        if(isset($request->storage_setting) && $request->storage_setting == 's3')
        {
            $request->validate(
                [
                    's3_key'                  => 'required',
                    's3_secret'               => 'required',
                    's3_region'               => 'required',
                    's3_bucket'               => 'required',
                    's3_url'                  => 'required',
                    's3_endpoint'             => 'required',
                    's3_max_upload_size'      => 'required',
                    's3_storage_validation'   => 'required',
                ]
            );
            $post['storage_setting']            = $request->storage_setting;
            $post['s3_key']                     = $request->s3_key;
            $post['s3_secret']                  = $request->s3_secret;
            $post['s3_region']                  = $request->s3_region;
            $post['s3_bucket']                  = $request->s3_bucket;
            $post['s3_url']                     = $request->s3_url;
            $post['s3_endpoint']                = $request->s3_endpoint;
            $post['s3_max_upload_size']         = $request->s3_max_upload_size;
            $s3_storage_validation              = implode(',', $request->s3_storage_validation);
            $post['s3_storage_validation']      = $s3_storage_validation;
        }

        if(isset($request->storage_setting) && $request->storage_setting == 'wasabi')
        {
            $request->validate(
                [
                    'wasabi_key'                    => 'required',
                    'wasabi_secret'                 => 'required',
                    'wasabi_region'                 => 'required',
                    'wasabi_bucket'                 => 'required',
                    'wasabi_url'                    => 'required',
                    'wasabi_root'                   => 'required',
                    'wasabi_max_upload_size'        => 'required',
                    'wasabi_storage_validation'     => 'required',
                ]
            );
            $post['storage_setting']            = $request->storage_setting;
            $post['wasabi_key']                 = $request->wasabi_key;
            $post['wasabi_secret']              = $request->wasabi_secret;
            $post['wasabi_region']              = $request->wasabi_region;
            $post['wasabi_bucket']              = $request->wasabi_bucket;
            $post['wasabi_url']                 = $request->wasabi_url;
            $post['wasabi_root']                = $request->wasabi_root;
            $post['wasabi_max_upload_size']     = $request->wasabi_max_upload_size;
            $wasabi_storage_validation          = implode(',', $request->wasabi_storage_validation);
            $post['wasabi_storage_validation']  = $wasabi_storage_validation;
        }

        foreach($post as $key => $data)
        {

            $arr = [
                $data,
                $key,
                \Auth::user()->id,
            ];

            \DB::insert(
                'insert into settings (`value`, `name`,`created_by`) values (?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ', $arr
            );
        }

        return redirect()->back()->with('success', __('Storage setting successfully updated.'));

    }


    public function saveTwilioSettings(Request $request){
        $post = [];
        $post['twilio_sid'] = $request->input('twilio_sid');
        $post['twilio_token'] = $request->input('twilio_token');
        $post['twilio_from'] = $request->input('twilio_from');
        $post['twilio_customer_notification'] = $request->has('twilio_customer_notification')?$request->input('twilio_customer_notification'):0;
        $post['twilio_vendor_notification'] = $request->has('twilio_vendor_notification')?$request->input('twilio_vendor_notification'):0;
        $post['twilio_quotation_notification'] = $request->has('twilio_quotation_notification')?$request->input('twilio_quotation_notification'):0;
        $post['twilio_sales_notification'] = $request->has('twilio_sales_notification')?$request->input('twilio_sales_notification'):0;
        $post['twilio_return_notification'] = $request->has('twilio_return_notification')?$request->input('twilio_return_notification'):0;
        $post['twilio_purchase_notification'] = $request->has('twilio_purchase_notification')?$request->input('twilio_purchase_notification'):0;
        // $post['twilio_payment_notification'] = $request->has('twilio_payment_notification')?$request->input('twilio_payment_notification'):0;
        // $post['twilio_reminder_notification'] = $request->has('twilio_reminder_notification')?$request->input('twilio_reminder_notification'):0;
    
    
        if(isset($post) && !empty($post) && count($post) > 0)
        {
            $created_at = $updated_at = date('Y-m-d H:i:s');
    
            foreach($post as $key => $data)
            {
                DB::insert(
                    'INSERT INTO settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `updated_at` = VALUES(`updated_at`) ', [
                                                                                                                                                                                                                      $data,
                                                                                                                                                                                                                      $key,
                                                                                                                                                                                                                      Auth::user()->id,
                                                                                                                                                                                                                      $created_at,
                                                                                                                                                                                                                      $updated_at,
                                                                                                                                                                                                                  ]
                );
            }
        }
    
        return redirect()->back()->with('success', __('Twilio updated successfully.'));
    }
    

    public function saveGoogleCalenderSettings(Request $request)
    {

        //dd($request->all());
        if(isset($request->is_enabled) && $request->is_enabled == 'on'){
            $validator = \Validator::make(
                $request->all(),
                [
                    'google_clender_id' => 'required',
                    'google_calender_json_file' => 'required',
                ]
            );
            if ($validator->fails()) {
                $messages = $validator->getMessageBag();
                return redirect()->back()->with('error', $messages->first());
            }
            $post['is_enabled'] = $request->is_enabled;
        }else{
            $post['is_enabled'] = 'off';
        }

        if ($request->google_calender_json_file)
        {
            //$dir       = storage_path() . '/googlecalender';
            $dir=storage_path(). '/'.md5(time());
            if (!is_dir($dir)) {
                File::makeDirectory($dir, $mode = 0777, true, true);
            }
            $file_name = $request->google_calender_json_file->getClientOriginalName();
            //$file_path =  md5(time()) . "." . $request->google_calender_json_file->getClientOriginalExtension();
              $file_path=md5(time()).'/'.md5(time()).".". $request->google_calender_json_file->getClientOriginalExtension();

            $file = $request->file('google_calender_json_file');
            $file->move($dir, $file_path);
            $post['google_calender_json_file']            = $file_path;
        }
        if ($request->google_clender_id) {
            $post['google_clender_id']            = $request->google_clender_id;
            foreach ($post as $key => $data) {
                \DB::insert(
                    'insert into settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ',
                    [
                        $data,
                        $key,
                        \Auth::user()->id,
                        date('Y-m-d H:i:s'),
                        date('Y-m-d H:i:s'),
                    ]
                );
            }
        }
        return redirect()->back()->with('success', __('Storage setting successfully updated.'));
    }

    public function saveSeoSettings(Request $request)
    {

            $validator = \Validator::make(
                $request->all(),
                [
                    'meta_keywords' => 'required',
                    'meta_description' => 'required',
                    'meta_image' => 'required',
                ]
            );
            if ($validator->fails()) {
                $messages = $validator->getMessageBag();
                return redirect()->back()->with('error', $messages->first());
            }

        if ($request->meta_image)
        {
            $img_name = time() . '_' . 'meta_image.png';
            $dir = 'uploads/logo/';
            $validation = [

                'max:' . '20480',
            ];

            $path = Utility::upload_file($request, 'meta_image', $img_name, $dir, $validation);
            if ($path['flag'] == 1) {
                $logo_dark = $path['url'];
            } else {
                return redirect()->back()->with('error', __($path['msg']));
            }


            $post['meta_image']  = $img_name;

        }

        $post['meta_keywords']            = $request->meta_keywords;
        $post['meta_description']            = $request->meta_description;

        foreach ($post as $key => $data) {
            \DB::insert(
                'insert into settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ',
                [
                    $data,
                    $key,
                    \Auth::user()->id,
                    date('Y-m-d H:i:s'),
                    date('Y-m-d H:i:s'),
                ]
            );
        }

        return redirect()->back()->with('success', __('SEO setting successfully updated.'));
    }

    public function saveCookieSettings(Request $request)
    {

        $validator = \Validator::make(
            $request->all(), [
                'cookie_title' => 'required',
                'cookie_description' => 'required',
                'strictly_cookie_title' => 'required',
                'strictly_cookie_description' => 'required',
                'more_information_title' => 'required',
                'contactus_url' => 'required',
            ]
        );
            
        $post = $request->all();

        unset($post['_token']);

        if ($request->enable_cookie)
        {
            $post['enable_cookie'] = 'on';
        }
        else{
            $post['enable_cookie'] = 'off';
        }
        if ( $request->cookie_logging)
        {
            $post['cookie_logging'] = 'on';
        }
        else{
            $post['cookie_logging'] = 'off';
        }

        $post['cookie_title']            = $request->cookie_title;
        $post['cookie_description']            = $request->cookie_description;
        $post['strictly_cookie_title']            = $request->strictly_cookie_title;
        $post['strictly_cookie_description']            = $request->strictly_cookie_description;
        $post['more_information_title']            = $request->more_information_title;
        $post['contactus_url']            = $request->contactus_url;

        $settings = Utility::settings();
        foreach ($post as $key => $data) {

            if (in_array($key, array_keys($settings))) {
                \DB::insert(
                    'insert into settings (`value`, `name`,`created_by`,`created_at`,`updated_at`) values (?, ?, ?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ', [
                        $data,
                        $key,
                        \Auth::user()->creatorId(),
                        date('Y-m-d H:i:s'),
                        date('Y-m-d H:i:s'),
                    ]
                );
            }
        }
        return redirect()->back()->with('success', __('Cookie setting successfully saved.'));
    }

    public function CookieConsent(Request $request)
    {
        $settings= Utility::settings();
        
        if($settings['enable_cookie'] == "on" && $settings['cookie_logging'] == "on"){
            $allowed_levels = ['necessary', 'analytics', 'targeting'];
            $levels = array_filter($request['cookie'], function($level) use ($allowed_levels) {
                return in_array($level, $allowed_levels);
            });
            $whichbrowser = new \WhichBrowser\Parser($_SERVER['HTTP_USER_AGENT']);
            // Generate new CSV line
            $browser_name = $whichbrowser->browser->name ?? null;
            $os_name = $whichbrowser->os->name ?? null;
            $browser_language = isset($_SERVER['HTTP_ACCEPT_LANGUAGE']) ? mb_substr($_SERVER['HTTP_ACCEPT_LANGUAGE'], 0, 2) : null;
            $device_type = self::get_device_type($_SERVER['HTTP_USER_AGENT']);

//            $ip = $_SERVER['REMOTE_ADDR'];
            $ip = '49.36.83.154';
            $query = @unserialize(file_get_contents('http://ip-api.com/php/' . $ip));


            $date = (new \DateTime())->format('Y-m-d');
            $time = (new \DateTime())->format('H:i:s') . ' UTC';


            $new_line = implode(',', [$ip, $date, $time,json_encode($request['cookie']), $device_type, $browser_language, $browser_name, $os_name,
                isset($query)?$query['country']:'',isset($query)?$query['region']:'',isset($query)?$query['regionName']:'',isset($query)?$query['city']:'',isset($query)?$query['zip']:'',isset($query)?$query['lat']:'',isset($query)?$query['lon']:'']);

            if(!file_exists(storage_path(). '/uploads/sample/data.csv')) {

                $first_line = 'IP,Date,Time,Accepted cookies,Device type,Browser language,Browser name,OS Name,Country,Region,RegionName,City,Zipcode,Lat,Lon';

                file_put_contents(storage_path() . '/uploads/sample/data.csv', $first_line . PHP_EOL , FILE_APPEND | LOCK_EX);
            }
            file_put_contents(storage_path() . '/uploads/sample/data.csv', $new_line . PHP_EOL , FILE_APPEND | LOCK_EX);

            return response()->json('success');
        }
        return response()->json('error');
    }
 
    public function get_device_type($user_agent) {
        $mobile_regex = '/(?:phone|windows\s+phone|ipod|blackberry|(?:android|bb\d+|meego|silk|googlebot) .+? mobile|palm|windows\s+ce|opera mini|avantgo|mobilesafari|docomo)/i';
        $tablet_regex = '/(?:ipad|playbook|(?:android|bb\d+|meego|silk)(?! .+? mobile))/i';

        if(preg_match_all($mobile_regex, $user_agent)) {
            return 'mobile';
        } else {

            if(preg_match_all($tablet_regex, $user_agent)) {
                return 'tablet';
            } else {
                return 'desktop';
            }

        }
    }



    public function chatgptkey(Request $request){
        if (\Auth::user()->type == 'Super Admin') {
            $user = \Auth::user();
            if (!empty($request->chatgpt_key)) {
                $post = $request->all();
                $post['chatgpt_key'] = $request->chatgpt_key;
                
                unset($post['_token']);
                $settings = Utility::settings();
                foreach ($post as $key => $data) {
                    
                    if (in_array($key, array_keys($settings))) { // this query change by me as per setiing table column
                        \DB::insert(
                            'insert into settings (`value`, `name`,`created_by`) values (?, ?, ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`) ', [
                                $data,
                                $key,
                                \Auth::user()->creatorId(),
                            ]
                        );
                    }
                }
                
            }
            return redirect()->back()->with('success', __('Chatgpykey successfully saved.'));
        } else {
            return redirect()->back()->with('error', __('Permission denied.'));
        }
    }


    

}