API Rest con Laravel 12

<?php

namespace App\Models;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Fortify\TwoFactorAuthenticatable;
use Laravel\Jetstream\HasProfilePhoto;
use Laravel\Sanctum\HasApiTokens;

use App\Models\Note;
use Illuminate\Database\Eloquent\Relations\HasMany;

class User extends Authenticatable implements MustVerifyEmail
{
    use HasApiTokens;

    /** @use HasFactory<\Database\Factories\UserFactory> */
    use HasFactory;
    use HasProfilePhoto;
    use Notifiable;
    use TwoFactorAuthenticatable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = [
        'password',
        'remember_token',
        'two_factor_recovery_codes',
        'two_factor_secret',
    ];

    /**
     * The accessors to append to the model's array form.
     *
     * @var array<int, string>
     */
    protected $appends = [
        'profile_photo_url',
    ];

    /**
     * Get the attributes that should be cast.
     *
     * @return array<string, string>
     */
    protected function casts(): array
    {
        return [
            'email_verified_at' => 'datetime',
            'password' => 'hashed',
        ];
    }

    public function notes(): HasMany    
    {
        return $this->hasMany(Note::class);
    }
}

php artisan make:resource Note

nano app/Http/Resources/Note.php

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class Note extends JsonResource
{
    /**
     * Transform the resource into an array.
     *
     * @return array<string, mixed>
     */
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'description' => $this->description,
            'created_at' => $this->created_at->format('d/m/Y'),
            'updated_at' => $this->updated_at->format('d/m/Y'),
        ];
    }
}

cd ~/notesApp
mkdir app/Http/Controllers/Api
nano app/Http/Controllers/Api/BaseController.php

poner este contenido en el fichero BaseController.php

<?php


namespace App\Http\Controllers\Api;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller as Controller;


class BaseController extends Controller
{
    /**
     * success response method.
     *
     * @return \Illuminate\Http\Response
     */
    public function sendResponse($result, $message, $code = 200)
    {
        $response = [
            'success' => true,
            'data'    => $result,
            'message' => $message,
        ];

        return response()->json($response, $code);
    }

    /**
     * return error response.
     *
     * @return \Illuminate\Http\Response
     */
    public function sendError($error, $errorMessages = [], $code = 200)
    {
        $response = [
            'success' => false,
            'message' => $error,
        ];

        if(!empty($errorMessages)){
            $response['info'] = $errorMessages;
        }

        return response()->json($response, $code);
    }
}

nano app/Http/Controllers/Api/AuthController.php

poner este contenido en el fichero AuthController.php

<?php
   
namespace App\Http\Controllers\Api;
   
use Illuminate\Http\Request;
use App\Http\Controllers\Api\BaseController as BaseController;
use Illuminate\Support\Facades\Auth;
use Validator;
use App\Models\User;
   
class AuthController extends BaseController
{
    public function login(Request $request)
    {
        if (Auth::attempt(['email' => $request->email, 'password' => $request->password])){ 
            $authUser = Auth::user(); 
            $result['token'] =  $authUser->createToken('MyAuthApp')->plainTextToken; 
            $result['name'] =  $authUser->name;
   
            return $this->sendResponse($result, 'User signed in');
        } 
        else { 
            return $this->sendError('Unauthorised.', ['error'=>'incorrect Email/Password']);
        } 
    }
    public function register(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required',
            'email' => 'required|email',
            'password' => 'required',
            'confirm_password' => 'required|same:password',
        ]);
   
        if ($validator->fails()){
            return $this->sendError('Error validation', $validator->errors());       
        }
   
        try {
            $input = $request->all();
            $input['password'] = bcrypt($input['password']);
            $user = User::create($input);
            $result['token'] =  $user->createToken('MyAuthApp')->plainTextToken;
            $result['name'] =  $user->name;
       
            return $this->sendResponse($result, 'User created successfully.');
        } catch (\Exception $e) {
            return $this->sendError('Registration Error' , $e->getMessage());
        }
    }
    public function logout(Request $request)
    {
        
        // Get user who requested the logout
        $user = request()->user(); //or Auth::user()
        // Revoke current user token
        $user->tokens()->where('id', $user->currentAccessToken()->id)->delete();
        $success['name'] =  $user->name;
        // return response()->json(['message' => 'User successfully signed out']);
        return $this->sendResponse($success, 'User successfully signed out.');
    }
   
}

nano routes/api.php

poner este contenido en el fichero api.php:

<?php
  
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
  
use App\Http\Controllers\Api\AuthController;
use App\Http\Controllers\Api\NoteController;

use App\Http\Controllers\Api\MailController;
  
/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
*/
  
Route::post('login', [AuthController::class, 'login']);
Route::post('register', [AuthController::class, 'register']);
     
Route::middleware('auth:sanctum')->group( function () {
    Route::resource('note', NoteController::class);
    Route::post('logout', [AuthController::class, 'logout']);
    Route::post('email', [MailController::class, 'sendEmail']);       
});

Route::middleware('auth:sanctum')->get('/user', function (Request $request) {
    return $request->user();
});

nano app/Http/Controllers/Api/NoteController.php

poner este contenido en el fichero NoteController.php:

<?php
   
namespace App\Http\Controllers\Api;
   
use Illuminate\Http\Request;
use App\Http\Controllers\Api\BaseController as BaseController;
use Validator;
use App\Models\Note;
use App\Http\Resources\Note as NoteResource;
   
class NoteController extends BaseController
{

    public function index()
    {
        $notes = Note::where('user_id', auth()->user()->id)
               ->get();
        return $this->sendResponse(NoteResource::collection($notess), 'Notes fetched.');
    }

    
    public function store(Request $request)
    {
        $input = $request->all();
        $validator = Validator::make($input, [
            'title' => 'required|max:255'
            'description' => 'required'
        ]);
        
        if ($validator->fails()){
            return $this->sendError($validator->errors());       
        }
        
        $note = new Note();
        $note->title = $request->title;
        $note->description = $request->description;
        $note->user_id = auth()->user()->id;
        $note->save();
        
        return $this->sendResponse(new NoteResource($note), 'Note created.');
    }

   
    public function show($id)
    {
        $note = Note::find($id);
        
        if (is_null($note)) {
            return $this->sendError('Note does not exist.');
        }
        return $this->sendResponse(new NoteResource($note), 'Note fetched.');
    }
    

    public function update(Request $request, Note $note)
    {
        $input = $request->all();

        $validator = Validator::make($input, [
            'title' => 'required|max:255'
            'description' => 'required'
        ]);

        if($validator->fails()){
            return $this->sendError($validator->errors());       
        }

        $note->title = $input['title'];
        //$note->title = $request->title;
        $note->description = $input['description'];
        //$note->description = $request->description;
        $note->save();
        
        return $this->sendResponse(new NoteResource($note), 'Note updated.');
    }
   
    public function destroy($id)
    {
        $note = Note::find($id);
        if (is_null($note)) {
            return $this->sendError('Note does not exist.', 'Note NOT deleted.');
        }
        else {
            $note->delete();
            return $this->sendResponse([], 'Note deleted.');
        }
    }
}

nano app/Http/Controllers/Api/MailController.php

poner este contenido en el fichero MailController.php:

<?php

namespace App\Http\Controllers\Api;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;
use App\Http\Controllers\Api\BaseController as BaseController;
use App\Mail\NewEmail;
use Validator;
use Exception;

class MailController extends BaseController
{     
    public function sendEmail(Request $request) {
        $validator = Validator::make($request->all(), [
            'to' => 'required|email',
            'from' => 'required|email',
            'subject' => 'required',
            'message' => 'required',
        ]);
        
        if ($validator->fails()) {
            // $status = 501;
            // return response()->json( ['status' => false, 'message' => $validator->errors()->getMessages()], 501);
            return $this->sendError('Error validation', $validator->errors()->getMessages(), 400); 
        } else {                                           
                try {
                    $email =  $request->json()->all();
                    $to = $email['to'];
                    $from = $email['from'];
                    $subject = $email['subject'];
                    $message = $email['message'];

                    $data = [
                        'subject' => $subject,
                        'to' => $to,
                        'from' => $from,
                        'message' => $message
                        ];
                    
                    Mail::send('emails.send', $data, function($message) {
                            $message->to('paco.portada@protonmail.com')->subject('hola');
                            $message->from('emisor@gmail.com');
                            });
                            
                    //Mail::to('paco.portada@protonmail.com')->send(new NewEmail($from, $subject, $message));
                    // $status = 200;
                    return $this->sendResponse('', 'Email has been sent to ' . $data['to']);
                } catch (Exception $exception) {
                    // $status = 554;
                    return $this->sendError('', 'Email has not been sent. Error: ' . $exception->getMessage(), 500);
                }
            }

      //return response()->json($message, $status);
    }
}

cd ~/todo
mkdir resources/views/emails

<!doctype html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0">
    <title>Nuevo mensaje</title>
</head>
<body>
    <p>Mensaje:</p>
<h3>Hola, es un mensaje de prueba</h3>
    
</body>
</html>

/*
|--------------------------------------------------------------------------
| Expiration Minutes
|--------------------------------------------------------------------------
|
| This value controls the number of minutes until an issued token will be
| considered expired. If this value is null, personal access tokens do
| not expire. This won't tweak the lifetime of first-party sessions.
|
*/

//'expiration' => null,
//'expiration' => 60 * 24 * 7,
'expiration' => 60,