Ajuda com Extends e envio para o banco

[Carlos Rocha]

Tenho uma abela de usuarios e uma tabela de administradores e clientes.

Gostaria de uma ajuda para implementar um cadastro

 

users -> name, login, passord (pronta)

admins -> user_id, registratiom, etc..
client -> user_id, registratiom, etc...

Queria ajuda para extender de user as classes Admin e Client

Olhem como estáAdmin

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;

use Illuminate\Database\Eloquent\Model;

class Admin extends User
{
    use HasFactory;  
    
    protected $fillable = [
        'name',
        'email',
        'password',
        'registration'
    ]; 

    private string $registration;

    public function create(
        string $name, 
        string $email, 
        string $password,
        string $registration
    )
    {
        //parent::create(['name'=>$name, 'email'=>$email, 'password'=>$password]);
        parent::$name = $name;
        parent::$email = $email;
        parent::$password = $password;
        $this->registration = $registration;
    }

}

User

<?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 Illuminate\Database\Eloquent\Relations\BelongsToMany;

class User extends Authenticatable
{
    /** @use HasFactory<\Database\Factories\UserFactory> */
    use HasFactory, Notifiable;

    static string $name;
    static string $email;
    static string $password;
    /**
     * The attributes that are mass assignable.
     *
     * @var list<string>
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];
    
    /**
     * The attributes that should be hidden for serialization.
     *
     * @var list<string>
     */
    protected $hidden = [
        'remember_token',
    ];

    /**
     * Get the attributes that should be cast.
     *
     * @return array<string, string>
     */
    protected function casts(): array
    {
        return [
            'email_verified_at' => 'datetime',
            'password' => 'hashed',
        ];
    }
    
    public function roles() : BelongsToMany {
        return $this->belongsToMany(Role::class);
    }  

    public function hasHole(Array $roleName): bool
    {        
        foreach ($this->roles as $role) {
            if ($role->name === $roleName) {
                return true;
            }
        }
        return false;
    }    

    public function hasHoles(Array $rolesName): bool
    {        
        foreach ($this->roles as $role) {
            foreach ($rolesName as $rolee) {
            if ($role->name === $rolee) {
                return true;
            }
         }
        }
        return false;
    }    

    public function hasAbility(string $ability): bool
    {
        foreach ($this->roles as $role) {
            if ($role->abilities->contains('name', $ability)) {
                return true;
            }
        }
        return false;
    }    
}

Como gravar um Admin na tabela admins sendo que ele é um User por extensão?

Tentei assim mas é claro que está errado...

public function store(Request $request, Admin $adminModel) {

        $dados = $request->validate([
            "name" => "required",
            "email" => "required|email",
            "password" => "required",
            "registration" => "required"
        ]);
        $dados["password"] =  Hash::make($dados["password"]);
        
        $admin = Admin::where("registration",  $dados["registration"])->first();
        
        if ($admin) 
            return 
                  redirect()->route("admin.new")
                            ->withErrors([
                                'fail' => 'Administrador já cadastrados<br>, favor verificar!'
                  ]);
                  
        $newAdmin = $adminModel->create(
                                   $dados['name'],
                                   $dados['email'],
                                   $dados['password'],
                                   $dados['registration']
                                );
        dd($newAdmin);
        $adminModel->save();
        //$adminModel::create($admin);
        
        return redirect()->route("admin.new")->with("success",'Cadastrado com sucesso');

    }

 

[Frank K Hosaka]

Pelo que eu entendi você quer cadastrar um administrador da tabela admin na tabela users. Para simplificar, a tabela admin só tem um campo chamado nome e o users também. O meu modelo ficou assim:

app > Models > User.php
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable {
    use HasFactory, Notifiable;
    public $timestamps = false;
    protected $fillable = ['name',];
}

app > Models > Admin.php
<?php 
namespace App\Models;
class Admin extends User {
    protected $table="admin";
}

app > Http > Controllers > Teste.php
<?php
namespace App\Http\Controllers;
use App\Models\User;
use App\Models\Admin;

class Teste {
    function index(){
        $admin=Admin::where('id',1)->value('nome');
        User::create(['name'=>$admin]);
    }
}

Eu gostei do verbo extends no model, eu não preciso mais fazer aquela longa lista de biblioteca que o model precisa usar, mas para pegar uma informação numa tabela e colocar em outra, acho mais fácil jogar o serviço para o Eloquent.

[Carlos Rocha]

Consegui:

 

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class AdminCreateFormRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true;
    }

/**
     * Get the validation rules that apply to the request.
     */
    public function rules(): array
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users,email',
            'password' => 'required|string',
            'registration' => 'required|unique:admins,registration'
        ];
    }

    /**
     * Custom messages for validation errors.
     */
    public function messages(): array
    {
        return [
            'name.required' => 'O campo nome é obrigatório.',
            'email.required' => 'O campo e-mail é obrigatório.',
            'email.unique' => 'Este e-mail já está cadastrado.',
            'password.required' => 'O campo senha é obrigatório.',
            'registration.required' => 'O campo registro é obrigatório.',
            'registration.unique' => 'Este registro já está cadastrado.',
        ];
    }
}

Controller:

    public function store(Request $request, AdminCreateFormRequest $adminCreateFormRequest) {

        $data = [
            "name" => $request->name,
            "email" =>  $request->email,
            "password" =>  Hash::make($request->password),
            "registration" =>  $request->registration
        ];        

        if (Admin::where('registration', $data['registration'])->exists()) {
            return redirect()->route('admin.new')->withErrors([
                'fail' => 'Administrador já cadastrado.<br>Favor verificar!'
            ]);
        }        

        $user = User::firstOrCreate([       
                'name'=> $data['name'],
                'email'=> $data['email']
            ],[
                'password'=>  $data['password']
            ]
        );
        
        $admin = Admin::firstOrCreate([        
                'user_id'=> $user->id,
                'registration'=> $data['registration']
        ]);
        
        return redirect()->route("admin.new")->with("success",'Cadastrado com sucesso');

    }