Gecko [ gandhischool.edu.np ]

Name	Size	Permission
Admin	[ DIR ]	drwxrwxr-x
AccountController.php	17.04 KB	-rw-rw-r--
Controller.php	361 B	-rw-rw-r--
GeneralController.php	361 B	-rw-rw-r--
LoginController.php	3.19 KB	-rw-rw-r--

Code Editor : AccountController.php

<?php

namespace App\Http\Controllers;

use App\Events\EmailEvent;
use App\Helpers\Constant;
use App\Helpers\OTPHelper;
use App\Http\Requests\PhoneNumberRequest;
use App\Http\Requests\WebRegisterRequest;
use App\Jobs\SendSMSJob;
use App\Models\SmsLogOutgoing;
use App\Models\SmsSentLog;
use App\Models\User;
use App\Models\UserDetail;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Session;
use Illuminate\Validation\ValidationException;

class AccountController extends Controller
{
    protected $guard;

private $otp;
    private $otp_valid_minutes;
    private $sms_service_enabled;

public function __construct(OTPHelper $otp)
    {
        $this->otp = $otp;
        $this->otp_valid_minutes = config('api.otp.valid_minutes');
        $this->sms_service_enabled = config('api.sms.service_enabled');
    }

//register section
    public function register()
    {
        return view('auth.register.register');
    }

public function register_post(WebRegisterRequest $request)
    {
        $email = $request->get('email');
        $mobile_number = $request->get('mobile_number');
        try {
            \DB::beginTransaction();

$user = User::create([
                'name' => $request->get('full_name'),
                'email' => $email,
                'mobile_number' => $mobile_number,
                'password' => Hash::make($request->get('password')),
                'is_verified' => '0',
                'is_blocked' => '0'
            ]);

UserDetail::create([
                'user_id' => $user->id,
                'full_name' => $request->get('full_name'),
                'address' => $request->get('address'),
                'language_id' => defaultLanguageId()
            ]);

$otp = $this->otp->generateOTP($mobile_number, $this->otp_valid_minutes, Constant::OTP__REGISTER);

if ($this->sms_service_enabled && $mobile_number) {
                session(['registered_username' => $mobile_number, 'registered_username_type' => 'phone']);
                $this->sendSMS($user, 'register', $otp->otp);
            }
            else if ($email) {
                session(['registered_username' => $email, 'registered_username_type' => 'email']);

$bucket = [
                    'otp_code' => $otp->otp,
                    'otp_valid_minutes' => $this->otp_valid_minutes,
                    'full_name' => $email,
                    'email' => $email,
                    'email_type' => 'registration_verify_email'
                ];
                event(new EmailEvent($bucket));
            }

session(['last_otp_sent_date' => now()]);

\DB::commit();

return redirect()->route('web.register.verify_otp');
        } catch (\Throwable $th) {
            \DB::rollback();
            return back()->withInput()->withErrors([$th->getMessage()]);
        }
    }

public function register_verify_otp(Request $request)
    {
        // dd(100);
        if (!Session::has('registered_username')) {
            return redirect()->route('web.session.expired');
        }

$eligbile_for_sms = $this->sms_service_enabled;

return view('auth.register.verify_otp', ['resend_otp_after_interval' => $this->resend_otp_after_interval(), 'eligbile_for_sms' => $eligbile_for_sms]);
    }

public function register_verify_otp_post(Request $request)
    {
        if (!Session::has('registered_username')) {
            return redirect()->route('web.session.expired');
        }

$username = $request->session()->get('registered_username');

$type = $request->session()->get('registered_username_type');

//verify that otp is correct
        $is_valid = $this->otp->isValidOTP($request->otp_code, $username, Constant::OTP__REGISTER);

// dd($is_valid);
        if (!$is_valid) {

return back()->withErrors(['Invalid OTP Code']);
        }

if ($type == 'email') {

$user = User::where('email', $username)->first();
            $user->email_verified_at = now();
            $user->is_verified=1;
            $user->save();

// $bucket = [
            //     'full_name' => $email,
            //     'email' => $email,
            //     'email_type' => 'registration_verified_email'
            // ];

// event(new EmailEvent($bucket));
        } else {
            // dd($username);
            $user = User::where('mobile_number', $username)->first();
            $user->phone_verified_at = now();
            $user->is_verified=1;
            $user->save();
        }

$request->session()->forget('registered_username');
        return redirect()->route('web.register.verify_otp.success');
    }

public function register_verify_otp_success()
    {
        return view('auth.register.otp_success');
    }

//resend verification code page
    function register_verify_otp_resend_post(Request $request)
    {
        if (!Session::has('registered_username')) {
            return redirect()->route('web.session.expired');
        }

$username = ($request->session()->get('registered_username'));
        $type = ($request->session()->get('registered_username_type'));

$otp = $this->otp->generateOTP($username, $this->otp_valid_minutes, Constant::OTP__REGISTER);

$user = User::where('email', $username)->orWhere('mobile_number', $username)->first();

if ($type == 'email') {
            session(['registered_username' => $username, 'registered_username_type' => 'email']);

$bucket = [
                'otp_code' => $otp->otp,
                'otp_valid_minutes' => $this->otp_valid_minutes,
                'full_name' => $user->name,
                'email' => $username,
                'email_type' => 'registration_verify_email'
            ];
            event(new EmailEvent($bucket));
        } else if ($this->sms_service_enabled && $type == 'phone') {
            session(['registered_username' => $username, 'registered_username_type' => 'phone']);
            $this->sendSMS($user, 'register', $otp->otp);
        }

session(['last_otp_sent_date' => now()]);

return redirect()->route('web.register.verify_otp');
    }

public function session_expired()
    {
        return view('auth.session_expired');
    }

//forgot password section

public function forgot_password()
    {
        return view('front.auth.password.forgot', ['request_after_interval' => $this->resend_forgot_password_request_interval()]);
    }

public function forgot_password_post(PhoneNumberRequest $request)
    {
        if (!$this->can_resend_forgot_password_request()) {
            return redirect()->route('password.forgot');
        }

$valid = $request->validate([
            'mobile_number'    => 'required|max:50|exists:users,mobile_number'
        ], [
            'mobile_number.exists' => 'This mobile number is not registered with our system.'
        ]);

if (!$valid) {
            return back()->withErrors(['Opps']);
        }

$mobile_number = $request->get('mobile_number');
        $user = User::where('mobile_number', $mobile_number)->first();

$otp = $this->otp->generateOTP($mobile_number, $this->otp_valid_minutes, Constant::OTP__FORGOT_PASSWORD_SMS);
        $this->sendSMS($user, 'forgot_password_sms', $otp->otp);

session(['last_otp_sent_date' => now()]);
        session(['forgot_password' => $mobile_number]);

return redirect()->route('password.forgot.verify_otp');
    }

private function send_forgot_password_email($email)
    {
        $this->otp_valid_minutes = config('general.otp.otp_valid_minutes');
        $otp = $this->otp->generateOTP($email, $this->otp_valid_minutes, Constant::OTP__FORGOT_PASSWORD);

session(['forgot_password' => $email]);

$bucket = [
            'otp_code' => $otp->otp,
            'otp_valid_minutes' => $this->otp_valid_minutes,
            'full_name' => $email,
            'email' => $email,
            'email_type' => 'forgot_password_email'
        ];

event(new EmailEvent($bucket));

$user = User::where('email_address', $email)->first();
        $eligbile_for_sms = false;

session(['last_otp_sent_date' => now()]);
        session(['eligbile_for_sms' => $eligbile_for_sms]);
    }

public function forgot_password_verify_otp(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }
        // dd($this->resend_otp_after_interval());

$eligbile_for_sms = session('eligbile_for_sms');
        // dd($eligbile_for_sms);

return view('front.auth.password.verify_otp', ['resend_otp_after_interval' => $this->resend_otp_after_interval(), 'eligbile_for_sms' => $eligbile_for_sms]);
    }

public function forgot_password_verify_otp_post(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }

$email = $request->session()->get('forgot_password');

//verify that otp is correct
        $is_valid = $this->otp->isValidOTP($request->otp_code, $email, Constant::OTP__FORGOT_PASSWORD);

// dd($is_valid);
        if (!$is_valid) {

throw ValidationException::withMessages([
                'otp_code' => __('Invalid OTP code'),
            ]);

redirect()->back()->withErrors('otp_code', 'Invalid OTP code');
        }

//update user table
        $user = User::where('email_address', $email)->first();
        $user->email_verified_at = now();
        $user->save();

return redirect()->route('password.forgot.update');
    }

public function forgot_password_verify_otp_resend_post(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }

if (!$this->can_resend_otp()) {
            return redirect()->route('password.forgot.verify_otp');
        }

$email = $request->session()->get('forgot_password');

$this->send_forgot_password_email($email);

return redirect()->route('password.forgot.verify_otp');
    }

public function forgot_password_verify_otp_post_sms(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }

$mobile_number = $request->session()->get('forgot_password');

//verify that otp is correct
        $is_valid = $this->otp->isValidOTP($request->otp_code, $mobile_number, Constant::OTP__FORGOT_PASSWORD_SMS);

// dd($is_valid);
        if (!$is_valid) {

throw ValidationException::withMessages([
                'otp_code' => __('Invalid OTP code'),
            ]);

redirect()->back()->withErrors('otp_code', 'Invalid OTP code');
        }

//update user table
        $user = User::where('mobile_number', $mobile_number)->first();
        $user->phone_verified_at = now();
        $user->save();

return redirect()->route('password.forgot.update');
    }

public function forgot_password_verify_otp_resend_post_sms(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }

if (!$this->can_resend_otp()) {
            return redirect()->route('password.forgot.verify_otp');
        }

$mobile_number = $request->session()->get('forgot_password');
        $user = User::where('mobile_number', $mobile_number)->first();

$otp = $this->otp->generateOTP($mobile_number, $this->otp_valid_minutes, Constant::OTP__FORGOT_PASSWORD_SMS);
        $this->sendSMS($user, 'forgot_password_sms', $otp->otp);

session(['last_otp_sent_date' => now()]);
        session(['forgot_password' => $mobile_number]);

return redirect()->route('password.forgot.verify_otp');
    }

public function forgot_password_update(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }

return view('front.auth.password.change_password');
    }

public function forgot_password_update_post(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }

$email = $request->session()->get('forgot_password');

$valid = $request->validate([
            'password' => 'min:8|max:20|required_with:confirm_password|same:confirm_password',
            'confirm_password' => 'min:8|max:20'
        ]);

$password = $request->get('password');

$user = User::where('email_address', $email)->first();
        $user->password = Hash::make($password);
        $user->save();

$bucket = [
            'full_name' => $email,
            'email' => $email,
            'email_type' => 'password_changed_email'
        ];

event(new EmailEvent($bucket));

$request->session()->forget('forgot_password');

return redirect()->route('password.forgot.update.success');
    }

public function forgot_password_update_post_sms(Request $request)
    {
        if (!Session::has('forgot_password')) {
            return redirect()->route('web.session.expired');
        }

$mobile_number = $request->session()->get('forgot_password');

$valid = $request->validate([
            'password' => 'min:8|max:20|required_with:confirm_password|same:confirm_password',
            'confirm_password' => 'min:8|max:20'
        ]);

$password = $request->get('password');

$user = User::where('mobile_number', $mobile_number)->first();
        $user->password = Hash::make($password);
        if (!$user->phone_verified_at) $user->phone_verified_at = now();
        $user->save();

$request->session()->forget('forgot_password');

return redirect()->route('password.forgot.update.success');
    }

public function forgot_password_update_success()
    {
        return view('front.auth.password.password_success');
    }

private function can_resend_otp()
    {
        if (!Session::has('last_otp_sent_date')) return true;

$interval = $this->resend_otp_after_interval();
        if ($interval[0] <= 0 && $interval[1] <= 0) return true;

return false;
    }

private function resend_otp_after_interval()
    {
        if (!Session::has('last_otp_sent_date')) return [0, 0];

$last_otp_sent_date = Session::get('last_otp_sent_date');
        // dd($last_otp_sent_date);
        $diff_seconds = ktm_diff_now($last_otp_sent_date, 'sec');
        // dd($diff_seconds);
        $otp_resend_after_minutes = config('api.otp.otp_resend_after_minutes');

$otp_resend_after_seconds = $otp_resend_after_minutes * 60;

$diff = $otp_resend_after_seconds - $diff_seconds;

$min = intval($diff / 60);
        $sec = $diff - $min * 60;
        $ret = [
            $min,
            $sec
        ];
        return $ret;
    }

private function can_resend_forgot_password_request()
    {
        if (!Session::has('last_otp_sent_date')) return true;

$interval = $this->resend_forgot_password_request_interval();
        if ($interval[0] <= 0 && $interval[1] <= 0) return true;

return false;
    }

private function resend_forgot_password_request_interval()
    {
        if (!Session::has('last_otp_sent_date')) return [0, 0];

$last_otp_sent_date = Session::get('last_otp_sent_date');
        // dd($last_otp_sent_date);
        $diff_seconds = ktm_diff_now($last_otp_sent_date, 'sec');
        $otp_resend_after_minutes = config('general.service.forgot_password_request_after_minutes');

$otp_resend_after_seconds = $otp_resend_after_minutes * 60;

$diff = $otp_resend_after_seconds - $diff_seconds;

$min = intval($diff / 60);
        $sec = $diff - $min * 60;
        $ret = [
            $min,
            $sec
        ];
        return $ret;
    }

//BEGIN - SEND SMS
    private function sendSMS(User $user, $type, $otp)
    {
        $text = 'Please use OTP code ' . $otp . '. Valid for ' . $this->otp_valid_minutes . 'minutes. ' . config('app.name');
        //log outgoing sms before dispatching
        $log = $this->log_sms_outgoing($user, $type, $text);

$sms_data = [
            'mobile_number' => $user->phone,
            'text' => $text
        ];

SendSMSJob::dispatch($sms_data, $log);
        $this->log_sms_sent_date($user->id);
    }

private function log_sms_sent_date($user_id)
    {
        $model = SmsSentLog::where('user_id', $user_id)->first();
        if (!$model) {
            SmsSentLog::create([
                'user_id' => $user_id,
                'last_sms_sent_date' => now()
            ]);
        } else {
            $model->last_sms_sent_date = now();
            $model->save();
        }
    }

private function log_sms_outgoing(User $user, $type, $message)
    {
        $log = SmsLogOutgoing::create([
            'user_id' => $user->id,
            'mobile_number' => $user->mobile_number,
            'sms_type' => $type,
            'message' => $message
        ]);
        return $log;
    }
    //END - SEND SMS
}

${this.title}

Code Editor : AccountController.php