some bug fix

.env.example

@@ -36,7 +36,7 @@ MAIL_PORT=1025
 MAIL_USERNAME=null
 MAIL_PASSWORD=null
 MAIL_ENCRYPTION=null
-MAIL_FROM_ADDRESS=null
+MAIL_FROM_ADDRESS=from@example.com
 MAIL_FROM_NAME="${APP_NAME}"
 
 AWS_ACCESS_KEY_ID=
@@ -54,4 +54,8 @@ MIX_PUSHER_APP_CLUSTER="${PUSHER_APP_CLUSTER}"
 
 FCM_KEY=null
 SOCKET_URL=192.168.x.x:3030
+SMSIR_WEBSERVICE_URL=https://ws.sms.ir/
+SMSIR_API_KEY=
+SMSIR_SECRET_KEY=
+SMSIR_LINE_NUMBER=
 

app/Enums/tables.php

@@ -63,6 +63,11 @@ return [
         'name' => 'Works',
         'singular_name' => 'Work',
     ],
+    'users' => [
+        'id' => 100,
+        'name' => 'Users',
+        'singular_name' => 'Users',
+    ],
 
     //Relation Table's
     'business_user' => [

app/Http/Controllers/AuthController.php

@@ -2,28 +2,40 @@
 
 namespace App\Http\Controllers;
 
-use App\Models\User;
+use App\Http\Resources\UserResource;
 use App\Models\Business;
-use App\Models\Fingerprint;
-use Illuminate\Support\Str;
-use Illuminate\Http\Request;
-use Illuminate\Validation\Rule;
+use App\Models\User;
+use App\Notifications\DBNotification;
+use App\Notifications\MailNotification;
 use Illuminate\Http\JsonResponse;
-use App\Http\Resources\UserResource;
+use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
-use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Notification;
+use Illuminate\Support\Str;
+use Illuminate\Validation\Rule;
 use Laravel\Socialite\Facades\Socialite;
-use Illuminate\Session\TokenMismatchException;
 use Symfony\Component\HttpFoundation\Response;
 
 class AuthController extends Controller
 {
+    /**
+     * Redirect user to google auth procedure
+     *
+     * @return mixed
+     */
     public function redirectToGoogle()
     {
         return Socialite::driver('google')->stateless()->redirect();
     }
 
+    /**
+     * Complete user authenticated when return from google auth
+     *
+     * @param Request $request
+     * @return \Illuminate\Contracts\Foundation\Application|\Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
+     */
     public function handleGoogleCallback(Request $request)
     {
         try {
@@ -31,33 +43,83 @@ class AuthController extends Controller
             $user = Socialite::driver('google')->stateless()->user();
             $find_user = User::where('email', $user->email)->first();
 
-            if ($find_user) {
+           if (!$find_user)
+           {
 
-                $find_user->update([
-                   'active' => true
+                $find_user = User::create($user->user + [
+                        'password' => Hash::make(Str::random(8)),
+                        'username' => $user->email,
+                        'active' => true,
+                        'has_password' => false
                     ]);
 
+           }
+
            Auth::setUser($find_user);
 
-            } else {
+           $finger_print = $this->createFingerPrint();
 
-                $user = User::create($user->user + [
-                        'password' => Hash::make('google-login-user'),
-                        'username' => $user->email,
-                        'active' => true
+           return redirect('http://localhost:3000/login?token='.$finger_print->token);
+
+        } catch (Exception $e) {
+            dd($e->getMessage());
+        }
+    }
+
+    /**
+     * Check email for guidance user state in the app
+     *
+     * @param Request $request
+     * @return JsonResponse
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function emailChecking(Request $request)
+    {
+        $this->validate($request, [
+            'email' => 'required|email',
         ]);
 
-                Auth::setUser($user);
+        $user = User::where('email', $request->email)->first();
 
+        if ($user && $user->has_password) {
+            // email exists in db
+            // user before set a password
+            return response()->json(['message' => 'user.exists'], 200);
         }
-            $finger_print = $this->createFingerPrint();
-            return redirect('http://localhost:3000/login?token='.$finger_print->token);
 
-        } catch (Exception $e) {
-            dd($e->getMessage());
+        if ($user && !$user->has_password) {
+            // email exists in db
+            // user hasn't password (we set password for user)
+            $this->sendVerification($request->email, 'google');
+            return response()->json(['message' => 'google'], 200);
+        }
+
+        if (!$user) {
+            // user not exists in db
+            $this->sendVerification($request->email, 'register');
+            return response()->json(['message' => 'register'], 200);
         }
+
+//        if (Cache::has($request->email)) {
+//            // email exists in cache
+//            $this->sendVerification($request->email, Cache::get($request->email)['type']);
+//            return response()->json(['message' => 'Send email for validation'], 200);
+//        }
+//
+//        if (!$user && !Cache::has($request->email)) {
+//            // user not exists in db and cache
+//            $this->sendVerification($request->email, 'register');
+//            return response()->json(['message' => 'Send email for validation'], 200);
+//        }
     }
 
+    /**
+     * Login existing user and notify him/her when login from new device
+     *
+     * @param Request $request
+     * @return array|JsonResponse
+     * @throws \Illuminate\Validation\ValidationException
+     */
     public function login(Request $request)
     {
         // todo: Logging in from a new device will result in sending a notification
@@ -70,6 +132,9 @@ class AuthController extends Controller
         if ($user && Hash::check($request->password, $user->password)) {
             Auth::setUser($user);
 
+            // for new device login
+            $this->loginNotif($this->firstOrNot());
+
             return [
                 'auth' => $this->createFingerPrint(),
                 'businesses' => Auth::user()->businesses->keyBy('id')->map(fn($b, $bid) => Business::info($bid))
@@ -82,156 +147,271 @@ class AuthController extends Controller
         ], Response::HTTP_NOT_FOUND);
     }
 
-
-    public function register(Request $request)
+    /**
+     * Verify link When user click on verification link that before send for user
+     * In this case user before login with google and now haven't password
+     *
+     * @param Request $request
+     * @return array
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function verification(Request $request)
     {
         $this->validate($request, [
-            'name' => 'required|string|max:225|min:2',
-            'username' => ['required', Rule::unique('users', 'username')],
-            'email'    => ['required', 'email', Rule::unique('users', 'email')],
-            'password' => 'required|string|min:8'
+            'email'    => 'required|email',
+            'signature' => 'required|string',
         ]);
 
-        $request->merge(['password' => Hash::make($request->password)]);
-
-        $code_data = ['verification_code' => $this->sendVerificationCode()];
-        $method_data = ['method' => 'registerMain'];
+        $this->checkValidation($request->email, 'google', $request->signature);
 
-        Cache::put($request->email, $request->all() + $code_data + $method_data, 3600); // remain one hour
+        Auth::setUser(User::where('email', $request->email)->first());
 
-        return \response()->json([
-            'message' => 'Code send for user and user must be verified.'],
-            Response::HTTP_OK);
+        return [
+            'auth' => $this->createFingerPrint(),
+            'businesses' => Auth::user()->businesses->keyBy('id')->map(fn($b, $bid) => Business::info($bid))
+        ];
 
     }
 
-    public function registerMain($user_info)
+    /**
+     * Send verification email for user
+     * Used by method in this class
+     *
+     * @param $email
+     * @param $type
+     */
+    public function sendVerification($email, $type)
     {
-        $user = User::create($user_info);
-
-        Auth::setUser($user);
-
-        return $this->createFingerPrint();
+        $signature = Str::random(30);
+
+        Cache::put($email, ['type' => $type, 'signature' => $signature], 3600);
+
+        Notification::route('mail', $email)->notify( new MailNotification([
+            'greeting' => __('notification.auth.verification.greeting'),
+            'subject' => __('notification.auth.verification.subject'),
+            'body' => __('notification.auth.verification.new_body'),
+            'link' => __('notification.auth.verification.link', [
+                'email' => $email,
+                'type' => $type,
+                'signature' => $signature
+            ])
+        ]));
     }
 
-    public function sendVerificationCode($contact_way = null)
+    /**
+     * This function used by some method in this class for check validation of signature
+     *
+     * @param $email
+     * @param $type
+     * @param $signature
+     * @return JsonResponse
+     */
+    public function checkValidation($email, $type, $signature)
     {
-        $verification_code = 1234; // rand(10001, 99999)
-
-        //send code for user with contact way
-
-        return $verification_code;
-    }
-
-    public function verification(Request $request)
+        if (!Cache::has($email) || Cache::get($email)['type'] !== $type || Cache::get($email)['signature'] != $signature)
         {
-        if (!Cache::has($request->email)) {
-            return \response()->json(['message' => 'Code expired.'], Response::HTTP_BAD_REQUEST);
+            abort(403, 'Validation failed');
         }
-
-        $user_info = Cache::get($request->email);
-
-        $this->validate($request, [
-            'email'    => 'required|email',
-            'verification_code' => 'required|string|min:4|max:4|in:'.$user_info['verification_code']
-        ]);
-
-        Cache::forget($request->email);
-
-        return  isset($user_info['method']) ?
-            call_user_func('self::'.$user_info['method'], $user_info) :
-            \response()->json(['message' => 'Code verified successfully.'], Response::HTTP_OK,);
+        Cache::forget($email);
     }
 
+    /**
+     * User request for forget password if before exists we send email for user
+     *
+     * @param Request $request
+     * @return JsonResponse
+     * @throws \Illuminate\Validation\ValidationException
+     */
     public function forgetPassword(Request $request)
     {
         $this->validate($request, [
             'email' => 'required|email|exists:users,email'
         ]);
 
-        $code_data = ['verification_code' => $this->sendVerificationCode()];
+        $this->sendVerification($request->email, 'forget');
 
-        Cache::put($request->email, $request->all() + $code_data, 3600); // remain one hour
-
-        return \response()->json([
-            'message' => 'Code send for user and user must be verified.'],
-            Response::HTTP_OK);
+        return response()->json(['message' => 'Send email for validation'], 200);
     }
 
+    /**
+     * If user verified in this step we update user password
+     *
+     * @param Request $request
+     * @return JsonResponse
+     * @throws \Illuminate\Validation\ValidationException
+     */
     public function updatePassword(Request $request)
     {
-        if (!Cache::has($request->email)) {
-            return \response()->json(['message' => 'Code expired.'], Response::HTTP_BAD_REQUEST);
-        }
-
         $this->validate($request, [
             'email'    => 'required|email',
             'password' => 'required|string|min:8|confirmed',
-            'verification_code' => 'required|string|min:4|max:4|in:'.Cache::get($request->email)['verification_code']
+            'signature' => 'required|string'
         ]);
 
+        $this->checkValidation($request->email, 'forget', $request->signature);
+
         $user = User::where('email', $request->email)->first();
 
         $user->update([
-           'password' => Hash::make($request->password)
+            'password' => Hash::make($request->password),
+            'has_password' => true
         ]);
 
-        Auth::setUser($user);
+//        Auth::setUser($user);
+//
+//        $this->createFingerPrint();
 
-        return $this->createFingerPrint();
+        return response()->json(['message' => 'Update successfully you must be login.'], 200);
     }
 
     /**
+     * If user verified we register user and login user
+     *
      * @param Request $request
-     * @return mixed
-     * @throws TokenMismatchException
+     * @return array
+     * @throws \Illuminate\Validation\ValidationException
      */
-    public function logout(Request $request)
+    public function register(Request $request)
     {
-        $token = $request->bearerToken();
+        $this->validate($request, [
+            'name' => 'required|string|max:225|min:2',
+            'username' => ['required', Rule::unique('users', 'username')],
+            'email'    => ['required', 'email', Rule::unique('users', 'email')],
+            'password' => 'required|string|min:6',
+            'signature' => 'required|string'
+        ]);
 
-        if (blank($token)) {
-            return new JsonResponse([
-                'message' => 'Not authorized request.',
-                'status' => Response::HTTP_UNAUTHORIZED
+        $this->checkValidation($request->email, 'register', $request->signature);
+
+        $request->merge(['password' => Hash::make($request->password)]);
+
+        $user = User::create($request->all()+ [
+                'has_password' => true
             ]);
+
+        Auth::setUser($user);
+
+        return [
+            'auth' => $this->createFingerPrint(),
+            'businesses' => Auth::user()->businesses->keyBy('id')->map(fn($b, $bid) => Business::info($bid))
+        ];
     }
 
-        /** @var Fingerprint $token */
-        $token = Auth::user()->fingerprints()->firstWhere([
-            'token' => $token,
+    /**
+     * Resend email for user (only one email per minute)
+     *
+     * @param Request $request
+     * @return JsonResponse
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    public function resendLink(Request $request)
+    {
+        $this->validate($request, [
+            'email' => 'required|email',
+            'type' => 'required|string'
         ]);
 
-        if ($token) {
-            return $token->delete();
+        $user_db = User::where('email', $request->email)->first();
+        $user_cache = Cache::get($request->email);
+
+        if ($user_db || $user_cache) {
+            $this->sendVerification($request->email, $request->type);
+            return response()->json(['message' => 'Link resend successfully'], 200);
         }
 
-        throw new TokenMismatchException('Invalid token!');
+        abort(403);
     }
 
     /**
-     * @param string $token
-     * @throws TokenMismatchException
+     * This function just used by front for checking validation of link whit signature
+     *
+     * @param $email
+     * @param $type
+     * @param $signature
+     * @return JsonResponse
      */
-    public function revoke(string $token)
+    public function linkVerification(Request $request)
     {
-        /** @var Fingerprint $token */
-        $token = Fingerprint::firstWhere([
-            'token' => $token,
-        ]);
+        if (!Cache::has($request->email) || Cache::get($request->email)['type'] !== $request->type || Cache::get($request->email)['signature'] != $request->signature)
+        {
+            abort(403, 'Validation failed');
+        }
+        return response()->json(['message' => 'Verified successfully. go on'], 200);
+    }
+
+    /**
+     * Create new token finger print when user login from new device or register
+     *
+     * @return mixed
+     */
+    public function createFingerPrint()
+    {
+        $attributes = [
+            'agent' => request()->getAgent(),
+            'ip' => request()->getClientIp(),
+            'os' => request()->getOS(),
+            'latitude' => \request()->getLocation()->getAttribute('lat'),
+            'longitude' => \request()->getLocation()->getAttribute('lon'),
+        ];
+
+        $values = [
+            'token' => Str::random(60)
+        ];
 
-        if ($token) {
-            return $token->delete();
+        return Auth::user()->fingerprints()->firstOrCreate($attributes, $attributes + $values);
     }
 
-        throw new TokenMismatchException();
+    /**
+     * Check user login from new device or not
+     * Used by some methode in this class
+     *
+     * @return mixed
+     */
+    public function firstOrNot()
+    {
+        return Auth::user()->fingerprints()->where([
+            ['agent', '!=',request()->getAgent()],
+            ['ip', '!=',request()->getClientIp()],
+            ['os', '!=',request()->getOS()],
+            ['latitude', '!=',\request()->getLocation()->getAttribute('lat')],
+            ['longitude', '!=',\request()->getLocation()->getAttribute('lon')],
+        ])->exists();
     }
 
+    /**
+     * Send notification for user that login from new device
+     *
+     * @param $send
+     */
+    public function loginNotif($send)
+    {
+        if ($send) {
+            Notification::send(Auth::user(), new MailNotification([
+                'greeting' => 'hi',
+                'subject' => 'login with another device',
+                'body' => 'Warning someone login to your account with new device. check it and dont worry',
+            ]));
+            Notification::send(Auth::user(), new DBNotification([
+                'body' => 'Warning someone login to your account with new device. check it and dont worry',
+            ]));
+        }
+    }
+
+    /**
+     * Return authenticated user
+     *
+     * @return UserResource
+     */
     public function auth()
     {
         return new UserResource(Auth::user());
     }
 
+    /**
+     * Return authenticated user with business info
+     *
+     * @return array
+     */
     public function authWithInfo()
     {
         return [
@@ -240,15 +420,13 @@ class AuthController extends Controller
         ];
     }
 
-    public function delete(Request $request)
-    {
-        Auth::user()->fingerprints()->delete();
-        unset(Auth::user()->token);
-        Auth::user()->delete();
-
-        return 'success';
-    }
-
+    /**
+     * When user accept google fcm push notification, google grant token to user
+     * This token save in user finger print for push notification
+     *
+     * @param Request $request
+     * @return array
+     */
     public function updateFcmToken(Request $request)
     {
         Auth::user()->fingerprints()->where(
@@ -265,20 +443,4 @@ class AuthController extends Controller
         return $this->authWithInfo();
     }
 
-    public function createFingerPrint()
-    {
-        $attributes = [
-            'agent' => request()->getAgent(),
-            'ip' => request()->getClientIp(),
-            'os' => request()->getOS(),
-            'latitude' => \request()->getLocation()->getAttribute('lat'),
-            'longitude' => \request()->getLocation()->getAttribute('lon'),
-        ];
-
-        $values = [
-            'token' => Str::random(60)
-        ];
-
-        return Auth::user()->fingerprints()->firstOrCreate($attributes, $attributes + $values);
-    }
 }

app/Http/Controllers/OldAuthController.php

@@ -0,0 +1,301 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\User;
+use App\Models\Business;
+use App\Models\Fingerprint;
+use App\Notifications\MailNotification;
+use Illuminate\Support\Facades\Notification;
+use Illuminate\Support\Str;
+use Illuminate\Http\Request;
+use Illuminate\Validation\Rule;
+use Illuminate\Http\JsonResponse;
+use App\Http\Resources\UserResource;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Facades\Cache;
+use Laravel\Socialite\Facades\Socialite;
+use Illuminate\Session\TokenMismatchException;
+use phpDocumentor\Reflection\Type;
+use Symfony\Component\HttpFoundation\Response;
+
+class OldAuthController extends Controller
+{
+    public function redirectToGoogle()
+    {
+        return Socialite::driver('google')->stateless()->redirect();
+    }
+
+    public function handleGoogleCallback(Request $request)
+    {
+        try {
+
+            $user = Socialite::driver('google')->stateless()->user();
+            $find_user = User::where('email', $user->email)->first();
+
+            if ($find_user) {
+
+                $find_user->update([
+                   'active' => true
+                ]);
+
+                Auth::setUser($find_user);
+
+            } else {
+
+                $user = User::create($user->user + [
+                        'password' => Hash::make('google-login-user'),
+                        'username' => $user->email,
+                        'active' => true
+                    ]);
+
+                Auth::setUser($user);
+
+            }
+            $finger_print = $this->createFingerPrint();
+            return redirect('http://localhost:3000/login?token='.$finger_print->token);
+
+        } catch (Exception $e) {
+            dd($e->getMessage());
+        }
+    }
+
+    public function login(Request $request)
+    {
+        // todo: Logging in from a new device will result in sending a notification
+        $this->validate($request, [
+            'email' => 'required|email|exists:users,email',
+            'password' => 'required|string|min:6'
+        ]);
+
+        $user = User::where('email', $request->email)->first();
+        if ($user && Hash::check($request->password, $user->password)) {
+            Auth::setUser($user);
+
+            return [
+                'auth' => $this->createFingerPrint(),
+                'businesses' => Auth::user()->businesses->keyBy('id')->map(fn($b, $bid) => Business::info($bid))
+            ];
+        }
+
+        return new JsonResponse([
+            'message' => trans('auth.failed'),
+            'status' => Response::HTTP_NOT_FOUND,
+        ], Response::HTTP_NOT_FOUND);
+    }
+
+
+    public function register(Request $request)
+    {
+        $this->validate($request, [
+            'name' => 'required|string|max:225|min:2',
+            'username' => ['required', Rule::unique('users', 'username')],
+            'email'    => ['required', 'email', Rule::unique('users', 'email')],
+            'password' => 'required|string|min:8'
+            ]);
+
+        $request->merge(['password' => Hash::make($request->password)]);
+
+        $code_data = ['verification_code' => $this->sendVerificationCode(\request('email'), 'register')];
+        $method_data = ['method' => 'registerMain'];
+
+        Cache::put($request->email, $request->all() + $code_data + $method_data, 3600); // remain one hour
+
+        return \response()->json([
+            'message' => 'Code send for user and user must be verified.'],
+            Response::HTTP_OK);
+
+    }
+
+    public function registerMain($user_info)
+    {
+        $user = User::create($user_info);
+
+        Auth::setUser($user);
+
+        return $this->createFingerPrint();
+    }
+
+    public function sendVerificationCode($contact_way, $type)
+    {
+        $verification_code = rand(10001, 99999);
+
+        Notification::route('mail', $contact_way)->notify( new MailNotification([
+            'greeting' => __('notification.auth.verification.greeting'),
+            'subject' => __('notification.auth.verification.subject'),
+            'body' => __('notification.auth.verification.body', ['code' => $verification_code]),
+            'link' => __('notification.auth.verification.link', ['email' => $contact_way, 'type' => $type]),
+        ]));
+
+        return $verification_code;
+    }
+
+    public function verification(Request $request)
+    {
+        if (!Cache::has($request->email)) {
+            return \response()->json(['message' => 'Code expired.'], Response::HTTP_BAD_REQUEST);
+        }
+
+        $user_info = Cache::get($request->email);
+
+        $this->validate($request, [
+            'email'    => 'required|email',
+            'verification_code' => 'required|string|min:4|max:4|in:'.$user_info['verification_code']
+        ]);
+
+//        Cache::forget($request->email);
+
+        if (isset($user_info['method'])) {
+            Cache::forget($request->email);
+            return call_user_func('self::'.$user_info['method'], $user_info);
+        }
+
+        return \response()->json(['message' => 'Code verified successfully.'], Response::HTTP_OK,);
+
+//        return  isset($user_info['method']) ?
+//            call_user_func('self::'.$user_info['method'], $user_info) :
+//            \response()->json(['message' => 'Code verified successfully.'], Response::HTTP_OK,);
+    }
+
+    public function forgetPassword(Request $request)
+    {
+        $this->validate($request, [
+            'email' => 'required|email|exists:users,email'
+        ]);
+
+        $code_data = ['verification_code' => $this->sendVerificationCode(\request('email', 'forget'))];
+
+        Cache::put($request->email, $request->all() + $code_data, 3600); // remain one hour
+
+        return \response()->json([
+            'message' => 'Code send for user and user must be verified.'],
+            Response::HTTP_OK);
+    }
+
+    public function updatePassword(Request $request)
+    {
+        if (!Cache::has($request->email)) {
+            return \response()->json(['message' => 'Code expired.'], Response::HTTP_BAD_REQUEST);
+        }
+
+        $this->validate($request, [
+            'email'    => 'required|email',
+            'password' => 'required|string|min:8|confirmed',
+            'verification_code' => 'required|string|min:4|max:4|in:'.Cache::get($request->email)['verification_code']
+        ]);
+
+        $user = User::where('email', $request->email)->first();
+
+        $user->update([
+           'password' => Hash::make($request->password)
+        ]);
+
+        Auth::setUser($user);
+
+        Cache::forget($request->email);
+
+        return $this->createFingerPrint();
+    }
+
+    /**
+     * @param Request $request
+     * @return mixed
+     * @throws TokenMismatchException
+     */
+    public function logout(Request $request)
+    {
+        $token = $request->bearerToken();
+
+        if (blank($token)) {
+            return new JsonResponse([
+                'message' => 'Not authorized request.',
+                'status' => Response::HTTP_UNAUTHORIZED
+            ]);
+        }
+
+        /** @var Fingerprint $token */
+        $token = Auth::user()->fingerprints()->firstWhere([
+            'token' => $token,
+        ]);
+
+        if ($token) {
+            return $token->delete();
+        }
+
+        throw new TokenMismatchException('Invalid token!');
+    }
+
+    /**
+     * @param string $token
+     * @throws TokenMismatchException
+     */
+    public function revoke(string $token)
+    {
+        /** @var Fingerprint $token */
+        $token = Fingerprint::firstWhere([
+            'token' => $token,
+        ]);
+
+        if ($token) {
+            return $token->delete();
+        }
+
+        throw new TokenMismatchException();
+    }
+
+    public function auth()
+    {
+        return new UserResource(Auth::user());
+    }
+
+    public function authWithInfo()
+    {
+        return [
+            'auth' => new UserResource(Auth::user()),
+            'businesses' => Auth::user()->businesses->keyBy('id') ->map(fn($b, $bid) => Business::info($bid))
+        ];
+    }
+
+    public function delete(Request $request)
+    {
+        Auth::user()->fingerprints()->delete();
+        unset(Auth::user()->token);
+        Auth::user()->delete();
+
+        return 'success';
+    }
+
+    public function updateFcmToken(Request $request)
+    {
+        Auth::user()->fingerprints()->where(
+            [
+                ['agent', request()->getAgent()],
+                ['ip', request()->getClientIp()],
+                ['os', request()->getOS()],
+                ['latitude', \request()->getLocation()->getAttribute('lat')],
+                ['longitude', \request()->getLocation()->getAttribute('lon')],
+            ]
+        )->firstOrFail()->update([
+            'fcm_token' => $request->fcm_token
+        ]);
+        return $this->authWithInfo();
+    }
+
+    public function createFingerPrint()
+    {
+        $attributes = [
+            'agent' => request()->getAgent(),
+            'ip' => request()->getClientIp(),
+            'os' => request()->getOS(),
+            'latitude' => \request()->getLocation()->getAttribute('lat'),
+            'longitude' => \request()->getLocation()->getAttribute('lon'),
+        ];
+
+        $values = [
+            'token' => Str::random(60)
+        ];
+
+        return Auth::user()->fingerprints()->firstOrCreate($attributes, $attributes + $values);
+    }
+}

app/Listeners/NotifHandler.php

@@ -33,10 +33,12 @@ class NotifHandler
         if (class_exists($event_class)) {
             $event_class::dispatch($message);
         }
+        if (auth()->user()) {
             Notification::send(auth()->user(), new SocketNotification(
                 [
                     'message' => enum('tables.'.$message->data->table_name.'.singular_name').enum('cruds.inverse.'.$message->data->crud_id.'.name'),
-                'payload'=>$business_info
+                    'payload'=> request('_business_info') ?? null
                 ]));
         }
     }
+}

app/Models/User.php

@@ -29,7 +29,7 @@ class User extends Model implements AuthenticatableContract, AuthorizableContrac
         'has_avatar' => 'boolean',
     ];
 
-    protected $fillable = ['name', 'email','mobile', 'username','password','active','has_avatar'];
+    protected $fillable = ['name', 'email','mobile', 'username','password','active','has_avatar', 'has_password'];
 
     protected $fillable_relations = ['projects'];
 

app/Notifications/MailNotification.php

@@ -73,6 +73,6 @@ class MailNotification extends Notification implements ShouldQueue
                     ->greeting($this->message['greeting'])
                     ->line($this->message['body'])
                     ->subject($this->message['subject'])
-                    ->action('Notification Action', url('/'));
+                    ->action('بیشتر', $this->message['link'] ?? url('/'));
     }
 }

database/migrations/2020_08_18_085016_create_users_table.php

@@ -21,6 +21,7 @@ class CreateUsersTable extends Migration
             $table->string('username')->unique();
             $table->string('password');
             $table->boolean('active')->default(false);
+            $table->boolean('has_password')->default(false);
             $table->boolean('has_avatar')->default(false);
             $table->timestamp('created_at')->nullable();
             $table->timestamp('updated_at')->useCurrent();

resources/lang/fa/notification.php

@@ -85,6 +85,16 @@ return [
         'suspended' => 'حساب مسدود شد.',
     ],
 
+    'auth' => [
+      'verification' => [
+          'greeting' => 'سلام کاربر گرامی!',
+          'subject' => 'لینک احراز هویت',
+          'body' => 'کد تایید شما :code',
+          'new_body' => 'برای ادامه فرایند ثبت نام لینک زیر را دنبال کنید.',
+          'link' => 'http://localhost:3000/auth/verification?email=:email&type=:type&signature=:signature'
+      ]
+    ],
+
     'sms' => [
         'templates' => [
             'template_name' => [

routes/api.php

@@ -6,12 +6,6 @@ $router->get('/lab', function () {
    throw new \Exception("^_^");
 });
 
-$router->get('/ntest', function () {
-    $user = \App\Models\User::find(1);
-    \Illuminate\Support\Facades\Notification::send($user, new \App\Notifications\SmsNotification(['verification_code' => "1234"]));
-//    (new \App\Utilities\HelperClass\NotificationHelper())
-//        ->makeSmsNotif('template_name', ['user' => 'myUser', 'business' => 'myBusiness']);
-})->middleware('bindBusiness');
 $router->group(['prefix' => 'actions'], function () use ($router) {
     $router->group(['prefix' => 'businesses'], function () use ($router) {
         $router->group(['prefix' => '{business}', 'middleware' => 'bindBusiness'], function () use ($router) {
@@ -25,6 +19,7 @@ $router->get('/{transaction}/redirection', 'CreditController@redirection');
 
 $router->group(['prefix' => 'auth'], function () use ($router) {
     $router->get('/', 'AuthController@auth')->middleware('auth:api');
+    $router->post('/checking', 'AuthController@emailChecking');
     $router->delete('/', 'AuthController@delete');
     $router->get('/info', 'AuthController@authWithInfo')->middleware('auth:api');
     $router->post('login', 'AuthController@login');
@@ -35,7 +30,10 @@ $router->group(['prefix' => 'auth'], function () use ($router) {
     $router->post('forget-password', 'AuthController@forgetPassword');
     $router->post('update-password', 'AuthController@updatePassword');
 
-    $router->post('verification', 'AuthController@verification');
+    $router->post('verification', 'AuthController@verification')->name('verification');
+
+    $router->post('resend', 'AuthController@resendLink')->middleware('throttle:1'); // one request per min
+    $router->post('link-verification', 'AuthController@linkVerification');
 
     $router->get('google/redirect', 'AuthController@redirectToGoogle')->name('google.redirect');
     $router->get('google/callback', 'AuthController@handleGoogleCallback')->name('google.callback');