File "APIController.php"

Full Path: /home/clickysoft/public_html/jmapi5.clickysoft.net/app/Http/Controllers/APIController.php
File size: 9.79 KB
MIME-type: text/x-php
Charset: utf-8

<?php

namespace App\Http\Controllers;

use App\Http\Requests\Admin\ForgotPasswordRequest;
use App\Http\Requests\Admin\RegisterRequest;
use App\Http\Requests\Admin\ResetPasswordRequest;
use App\Http\Requests\Admin\UpdatePasswordRequest;
use App\Http\Requests\Admin\UpdateProfileRequest;
use App\Models\User;
use App\Notifications\ForgotPasswordNotification;
use App\Notifications\RegisterNotification;
use App\Notifications\VerifyEmail;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Validator;
use Symfony\Component\HttpFoundation\Response;

class APIController extends Controller
{
    public function login(Request $request)
    {
        $credentials = $request->only('email', 'password');

        //Validate credential
        $validator = Validator::make($credentials, [
            'email' => 'required|email',
            'password' => 'required'
        ]);

        //Send failed response if request is not valid
        if ($validator->fails()) {
            return response()
                ->json(['errors' => $validator->messages()], 422);
        }

        if (!auth()->attempt($credentials)) {
            return response()->json([
                'message' => 'The given data was invalid.',
                'errors' => [
                    'password' => [
                        'Invalid credentials'
                    ],
                ]
            ], 422);
        }

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

        if (auth()->user()->status == 0) {
            return response()->json([
                'message' => 'Account disabled.',
                'errors' => [
                    'email' => [
                        'Your account is disabled, please contact administrator.'
                    ],
                ]
            ], 422);
        }

        if (!auth()->user()->hasVerifiedEmail()) {
            return response()->json([
                'message' => 'Email not verified.',
                'errors' => [
                    'email_verification' => [
                        'Your email is not verified.'
                    ],
                ]
            ], 422);
        }

        $authToken = $user->createToken('auth-token')->plainTextToken;

        return response()->json([
            'user' => [
                'id' => $user->id,
                'user_type' => $user->user_type,
                'name' => $user->name,
                'email' => $user->email,
                'phone_number' => $user->phone_number,
                'company' => $user->company,
                'secondary_email' => $user->secondary_email,
                'secondary_phone' => $user->secondary_phone,
                'secondary_name' => $user->secondary_name,
                'email_verified' => $user->hasVerifiedEmail(),
                'status' => $user->status,
                'sms_notification' => $user->sms_notification,
                'profile_image' => $user->profile_image->original_url ?? "",
                'role' => isset($user->roles[0]) ? [
                    'role_id' => $user->roles[0]->id,
                    'role_name' => $user->roles[0]->title,
                ]: [],
            ],
            'access_token' => $authToken,
        ]);
    }

    public function register(RegisterRequest $request)
    {
        $token = md5(uniqid(rand(), true));
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'phone_number' => $request->phone_number,
            'status' => 1,
            'sms_notification' => (int)$request->sms_notification === 1 ? 1 : 0,
            'user_type' => 3,
            'password' => $request->password,
            'email_token' => $token
        ]);

        if ($request->file('profile_image', false)) {
            $user->addMediaFromRequest('profile_image')->toMediaCollection('profile_image', 'user');
        }

        // Assign user role
        $user->roles()->attach(3);

        try {
            //$user->notify((new RegisterNotification())->delay(now()->addSeconds(5)));
            $user->notify((new VerifyEmail($token))); //->delay(now()->addSeconds(5)));
        } catch (\Exception $e) {
            \Log::info($e->getMessage());
        }

        return response()->json([
            'message' => 'User created successfully. Kindly check your inbox to verify email.',
        ], Response::HTTP_OK);
    }

    public function update_profile(UpdateProfileRequest $request)
    {
        $user = auth()->user();
        $user->update(
            $request->all(),
        );

        if ($request->file('profile_image', false)) {
            if (!empty($user->profile_image)) {
                $user->profile_image->delete();
            }
            $user->addMediaFromRequest('profile_image')->toMediaCollection('profile_image', 'user');
        }

        return response()->json([
            'message' => 'Profile updated successfully',
        ], Response::HTTP_OK);
    }

    public function get_user()
    {
        $user = auth()->user();
        return response()->json(['user' => [
            'id' => $user->id,
            'user_type' => $user->user_type,
            'name' => $user->name,
            'email' => $user->email,
            'phone_number' => $user->phone_number,
            'company' => $user->company,
            'fax_number' => $user->fax_number,
            'server_timezone' => date_default_timezone_get(),
            'status' => $user->status,
            'sms_notification' => $user->sms_notification,
            'profile_image' => $user->profile_image ? [
                "url" => $user->profile_image->url,
                "thumbnail" => $user->profile_image->thumbnail,
                "preview" => $user->profile_image->preview,
            ] : null,
        ]]);
    }

    function logout(Request $request)
    {
        $request->user()->tokens()->delete();
        return response()->json(['message' => "User has been logged out successfully."]);
    }

    public function forgot_password(ForgotPasswordRequest $request)
    {
        $resetCode = substr(number_format(time() * rand(), 0, '', ''), 0, 6);

        $user = User::whereEmail($request->input("email"))->first();

        if (!$user)
            return response()->json([
            'message' => "This user does not exists.",
            'errors' => ["error" => ["This user does not exists."]]
        ], 422);

        $user->password_reset_code = $resetCode;
        $user->save();
        try {
            $user->notify(new ForgotPasswordNotification($resetCode));
        } catch (\Exception $e) {
            Log::info($e->getMessage());
        }
        return response()->json(['message' => "A Password reset code has been sent to your email address."]);
    }

    public function reset_password(ResetPasswordRequest $request)
    {
        $user = User::whereEmail($request->input("email"))
            ->wherePasswordResetCode($request->input("password_reset_code"))
            ->first();

        if (empty($user)) {
            return response()->json([
                'message' => "The given data was invalid.",
                'errors' => ["password_reset_code" => ["The Password Reset Code is invalid or user does not exists."]]
            ], 422);
        }

        $user->password = \Hash::make($request->input("new_password"));
        $user->password_last_changed = new \DateTime;
        $user->password_reset_code = null;
        $user->save();

        return response()->json(['message' => "Password has been changed successfully."]);
    }

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

        $user = User::where('email_token', $request->get('token'))->first();
        if (empty($user)) {
            return response()->json([
                'message' => "Invalid token.",
                'errors' => ["token" => ["The given token is invalid."]]
            ], 422);
        }

        $user->email_verified_at = now();
        $user->email_token = null;
        $user->save();

        return response()->json([
            'message' => "Email verified successfully.",
        ], Response::HTTP_OK);
    }

    public function resendVerificationEmail(Request $request)
    {
        $request->validate([
            'email' => 'required|exists:users,email',
        ]);

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

        if (empty($user)) {
            return response()->json([
                'message' => "Invalid email.",
                'errors' => ["token" => ["This email does not exists in our records."]]
            ], 422);
        }

        if($user->hasVerifiedEmail()){
            return \response()->json([
                'message' => 'Email already verified.',
                'errors' => ["email" => ["You have already verified your email."]]
            ])->setStatusCode(Response::HTTP_UNPROCESSABLE_ENTITY);
        }else{
            try {
                $token = md5(uniqid(rand(), true));
                $user->notify((new VerifyEmail($token)));
                $user->email_token = $token;
                $user->save();

                return \response()->json([
                    'message' => 'Verification link sent to your email address.',
                ])->setStatusCode(Response::HTTP_OK);

            } catch (\Exception $e) {
                Log::info($e->getMessage());
                return \response()->json([
                    'message' => 'Email not sent.',
                    'errors' => ["email" => ["Something went wrong."]]
                ])->setStatusCode(Response::HTTP_UNPROCESSABLE_ENTITY);
            }
        }
    }

    public function update_password(UpdatePasswordRequest $request)
    {
        auth()->user()->update($request->validated());
        return response()->json(['message' => "Password updated successfully."]);
    }
}