birzha-legalizasia/app/Http/Controllers/API/ClientController.php

<?php

namespace App\Http\Controllers\API;

use App\Http\Requests\API\AddClientRequest;
use App\Http\Requests\API\LoginRequest;
use App\Http\Requests\API\RegisterRequest;
use App\Http\Requests\API\ClientRequest;
use App\Http\Requests\API\ResetPassword;
use App\Http\Resources\ClientResource;
use App\Mail\EmailVerification;
use App\Models\Account;
use App\Models\Client;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Lang;
use App\Http\Controllers\Controller;
use App\Notifications\EmailVerify;
use App\Notifications\PasswordReset;

class ClientController extends Controller
{
    public function login(LoginRequest $request){

        $client = Client::where('email', $request->input('email'))->first();

        if($client)
        {
            if($client->is_suspended)
            {
                return response()->json([
                    'message' => trans('auth.suspended')
                ], 422);
            }
            elseif (!$client->is_verified)
            {
                return response()->json([
                    'message' => trans('auth.not_verified')
                ], 422);
            }

            if (!Hash::check(request()->password, $client->password)){
                return response()->json([
                    'message' => trans('auth.unauthorized')
                ], 422);
            }

            $credentials = $request->only('email', 'password');

            Auth::attempt($credentials);

            $client->tokens()->delete();

            $client->token = $client->createToken('auth_token')->plainTextToken;

            return ClientResource::make($client);
        }
        return response()->json(['message' => Lang::get('auth.email_not_found')], 404);
    }

    public function signup(RegisterRequest $request){
        $client = new Client($request->only(['email','firstname','lastname']));
        $client->password = Hash::make($request->input('password'));

        $email_verification = (bool) config('settings.email_verification');
        $client->is_verified = ! $email_verification;

        if($email_verification)
        {
            $client->verification_token = rand(10000, 99999);
            $client->notify(new EmailVerify($request->firstname,  $client->verification_token));
        }

        $account = Account::create([
            'country_id' => $request->country,
            'type' => $request->account_type
        ]);

        $client->account()->associate($account)->save();
        if($client->is_verified){
            Auth::login($client);
            $client->token = $client->createToken('auth_token')->plainTextToken;
        }

        return ClientResource::make($client);
    }

    public function verifyEmail(Request $request){
        $request->validate([
            'email' => 'required|email',
            'token' => 'required'
        ]);

        $client = Client::where('email', $request->email)->first();

        if($client){
            if($client->verification_token === $request->token){
                $client->is_verified = 1;
                $client->save();

                Auth::login($client);

                $client->token = $client->createToken('auth_token')->plainTextToken;

                return ClientResource::make($client);
            }
            else{
                return response()->json(['message' => trans('auth.token_mismatch')], 401);
            }
        }
        else{
            return response()->json([
                'message' => trans('auth.user_not_found')
            ], 404);
        }
    }

    public function client(Request $request) {
        if($client = $request->user()){
            return ClientResource::make($client);
        }
        return response()->json([
            'message' => trans('auth.token_expired')
        ], 401);
    }

    public function logout(Request $request) {
        $request->user()->currentAccessToken()->delete();
        return response()->json([
            'message' => 'ok'
        ], 200);
	}

    public function sendPasswordResetLinkEmail(Request $request) {
        try{
            $request->validate(['email' => 'required|email']);

            $user = Client::where('email', $request->email)->first();
            if (!$user) {
                return response()->json([
                    'message' => trans('auth.user_not_found')
                ], 404);
            }

            $token = rand(1000, 9999);

            $user->notify(new PasswordReset($user->firstname, $token));

            $user['verification_token'] = $token;

            $user->save();

            return response()->json([
                'message' => trans('auth.sent_reset_code')
            ], 200);
        }
        catch(\Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 200);
        }
	}

    public function updatePassword(ResetPassword $request) {
        try{

            $user = Client::where('email', $request->email)->first();

            if(!$user){
                return response()->json([
                    'message' => trans('auth.user_not_found')
                ], 404);
            }

            Log::info($user);
            Log::info($request);
            if($request->token == $user->token){
                $user['password'] = Hash::make($request->password);
                $user->save();
                return response()->json([
                    'message' => 'OK'
                ], 200);
            }

            return response()->json([
                'message' => trans('auth.invalid_token')
            ], 404);
        }
        catch(\Exception $e){
            return response()->json([
                'message' => $e->getMessage()
            ], 400);
        }
    }

    public function updateClient(ClientRequest $request){

        $client = $request->user();

        $data = $request->only('firstname', 'lastname', 'password');

        if (!isset($data['password']) || !$data['password']) {
            unset($data['password']);
        }
        else {
            $data['password'] = Hash::make($data['password']);
        }

        if($client->fill($data)->save()){
            return ClientResource::make($client);
        }

        return response()->json([
            'message' => trans('app.account.update_profile_error')
        ],400);
    }

    public function registerClient(AddClientRequest $request)
    {
        $client = new Client($request->only(['email','firstname','lastname']));
        $client->password = Hash::make($request->input('password'));
        $client->is_verified = true;
        $client->account_id = $request->user()->account_id;

        if($client->save()){
            return ClientResource::make($client);
        }

        return response()->json([
            'message' => trans('app.account.update_profile_error')
        ],400);

    }

    public function accountClients(){
        return ClientResource::collection(request()->user()->account->clients);
    }
}