bella_masala_laravel/app/Http/Controllers/AuthController.php

<?php

namespace App\Http\Controllers;

use App\Http\Resources\UserResource;
use Auth;
use Illuminate\Http\Request;
use App\Models\User;
use App\Traits\ApiResponseHelper;
use App\Traits\ImageHelper;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Validator;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Password;

class AuthController extends Controller
{
    use AuthorizesRequests, ValidatesRequests;
    use ApiResponseHelper, ImageHelper;

    public function login(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'email' => ['required', 'email'],
            'password' => ['required', 'min:6'],
            'type' => ['required', 'in:super_admin,admin,waiter,client'],       
        ]);

        if ($validator->fails()) {
            return $this->apiResponse(false, $validator->errors()->first(), $validator->errors());
        }

        try {
            $user = User::where([['email', $request->email], ['type', $request->type]])->first();
            if (!$user || !Hash::check($request->password, $user->password)) {
                $message = __('messages.invalid_credentials');
                return $this->apiResponse(false, $message);
            }

            if (!($user->status == "active")) {
                return $this->apiResponse(false, $user->status_reason);
            }

            $token = $user->createToken($user->email)->plainTextToken;

            $data = collect([
                'user' => new UserResource($user),
                'token' => $token
            ]);
            $message = __('messages.authorized');
            return $this->apiResponse(true, $message, $data);
        } catch (\Throwable $exception) {
            return $this->apiResponse(false, $exception->getMessage());
        }
    }

    public function register(Request $request)
    {

        $validator = Validator::make($request->all(), [
            'name' => ['required', 'min: 3'],            
            'email' => ['required', 'email', 'unique:users'],
            'password' => ['required', \Illuminate\Validation\Rules\Password::min(8)],
            'country_code' => ['required'],
            'phone' => ['required', 'min: 8', 'max:11'],
            'image' => ['nullable', 'image'],
        ]);
        if ($validator->fails()) {
            return $this->apiResponse(false, $validator->errors()->first(), $validator->errors());
        }
        try {
            DB::beginTransaction();
            $user = new User();
            $user->name = $request->name;
            $user->email = strtolower($request->email);
            $user->password = Hash::make($request->password);
            $user->country_code = $request->country_code;
            $user->phone = $request->phone;
            $user->type = "client";
            $user->save();
            if ($request->image) {
                $prefix = 'profile';
                $profileImagePath = $this->uploadFile($request->image, $prefix, false);
                $user->image = $profileImagePath;
                $user->save();
            }
            DB::commit();
            $user->refresh();
            $token = $user->createToken($user->email)->plainTextToken;
            $data = collect([
                'user' => new UserResource($user),
                'token' => $token
            ]);
            $message = __('messages.account_created');
            return $this->apiResponse(true, $message,$data);
        } catch (\Throwable $exception) {
            return $this->apiResponse(false, $exception->getMessage());
        }
    }

        public function loggedInUser(Request $request)
    {
        try {
            $user = Auth::user();

            if (!($user->status == "active")) {
                return $this->apiResponse(false, $user->status_reason);
            }

            $token = $user->createToken($user->email)->plainTextToken;
            $data = collect([
                'user' => new UserResource($user),
                'token' => $token
            ]);
            $message = __('messages.authorized');
            return $this->apiResponse(true, $message, $data);
        } catch (\Throwable $exception) {
            return $this->apiResponse(false, $exception->getMessage());
        }
    }

    public function updatePassword(Request $request)
    {

      $validator = Validator::make($request->all(), [
          'password' => ['required', 'min: 8'],
          'confirm_password' => ['required', 'min: 8'],
      ]);
      
      if ($validator->fails()) {
          return $this->apiResponse(false, $validator->errors()->first(), $validator->errors());
      }
      
      try {
            $user = Auth::user();

            if ($request->password != $request->confirm_password) {
                return $this->apiResponse(false, __('messages.passwords_not_same'));
            }
          
           

          DB::beginTransaction();

          $user->password = Hash::make($request->password);
          $user->tokens()->delete();
          $user->save();
          DB::commit();
          $message = __('messages.password_updated');

            return $this->apiResponse(true, $message, new UserResource($user));
        } catch (\Throwable $exception) {
            return $this->apiResponse(false, $exception->getMessage());
        }
    }


    public function updateFcmToken(Request $request)
    {

      $validator = Validator::make($request->all(), [
          'token' => ['required', 'min: 8'],
      ]);
      
      if ($validator->fails()) {
          return $this->apiResponse(false, $validator->errors()->first(), $validator->errors());
      }
      
      try {
          $user = Auth::user();
          DB::beginTransaction();
          $user->notification_token = $request->token;
          $user->save();
          DB::commit();
          $message = __('messages.token_updated');

            return $this->apiResponse(true, $message);
        } catch (\Throwable $exception) {
            return $this->apiResponse(false, $exception->getMessage());
        }
    }


    public function updateUser(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => ['sometimes', 'min: 3'],
            'email' => ['sometimes', 'email', 'unique:users'],
            'country_code' => ['sometimes'],
            'phone' => ['sometimes', 'min: 8', 'max:11'],
            'password' => ['sometimes', \Illuminate\Validation\Rules\Password::min(8)],
            'image' => ['nullable', 'image'],
        ]);
        
        if ($validator->fails()) {
            return $this->apiResponse(false, $validator->errors()->first(), $validator->errors());
        }

        try {
            DB::beginTransaction();
            $user = Auth::user();

            if ($request->name) {
                $user->name = $request->name;
            }

            if ($request->country_code) {
                $user->country_code = $request->country_code;
                $user->phone_verified_at = null;
            }

            if ($request->phone) {
                $user->phone = $request->phone;
                $user->phone_verified_at = null;
            }

            if ($request->email) {
                $user->email = $request->email;
                $user->email_verified_at = null;
            }

            $user->save();

            if ($request->image) {
                $prefix = 'profile';
                $profileImagePath = $this->updateFile($request->image, $user->image,$prefix, false);
                $user->image = $profileImagePath;
                $user->save();
            }

            DB::commit();
            $message = __('messages.user_updated');
            return $this->apiResponse(true, $message, );
        } catch (\Throwable $exception) {
            return $this->apiResponse(false, $exception->getMessage());
        }
    }

    public function destroy($id)
    {

        $user = Auth::user();
        if($id != $user->id) {
            return $this->apiResponse(false, __('messages.not_authorized'),);
        }

        if($id == 1){
            return $this->apiResponse(false, __('messages.user_not_deletable'),);
        }else{
            //under_deletion
            try {
            DB::beginTransaction();
            $user = User::where('id',$id)->firstorfail();
            $user->status = 'under_deletion';
            $user->status_reason = __('messages.account_deletion_review');
            $user->save();
            DB::commit();
            return $this->apiResponse(true, __('messages.account_deletion_received'));
        } catch (\Throwable $exception) {
            DB::rollBack();
            return $this->apiResponse(false, $exception->getMessage());
        }

        }


    }

}