GeordieJackson

It looks like you've been trying to search for $request['name'] whereas your search field is passed as $request['search'];

Just change your method to:

public static function search($request)
{
    $categories = Category::query();

    if (isset($request['search'])) {
        $categories = $categories->where('name', 'like', '%'.$request['search'].'%');
    }

    return $categories->paginate(1);
}

and you should be there.

You may also need to put:

Route::resource('categories', 'CategoryController');

Route::post('categories', [CategoryController::class, 'index']);

In your routes too as you're posting to an index method. Which is actually another no-no!

It looks like you've been trying to search for $request['name'] whereas your search field is passed as $request['search'];

Just change your method to:

public static function search($request)
{
    $categories = Category::query();

    if (isset($request['search'])) {
        $categories = $categories->where('name', 'like', '%'.$request['search'].'%');
    }

    return $categories->paginate(1);
}

and you should be there.

You may also need to put:

Route::resource('categories', 'CategoryController');

Route::post('categories', [CategoryController::class, 'index']);

In your routes too as you're posting to an index method. Which is actually another no-no!

Sorry, I was using a collection to test this rather than the request Object.

Try changing the method to:

public static function search($request)
{
    $categories = Category::query();

    if (isset($request->name) || isset($request['name'])) {
        $categories = $categories->where('name', 'like', '%'.$request['name'].'%');
    }

    return $categories->paginate(2);
}

This should work with either the request object or the request->all() array.

You shouldn't have a collection when you're calling the paginate method.

Have you copied and pasted my method exactly?

i.e.

public static function search($request)
{
    $categories = Category::query();

    if (array_key_exists('name', $request)) {
        $categories = $categories->where('name', 'like', '%'.$request['name'].'%');
    }

    return $categories->paginate(1);
}

Note: I've changed collect() to array_key_exists() - as you're passing in an array rather than a collection.

Just change it to:

if (collect($request)->has('name')) 

Here's the search function refactored:

public static function search($request)
{
    $categories = Category::query();

    if ($request->has('name')) {
        $categories = $categories->where('name', 'like', '%'.$request['name'].'%');
    }

    return $categories->paginate(1);
}

I've still no idea what you're trying to achieve with $string, as you ignored my question, so I'll leave you with this and hope it helps.

If you have a $category it will be a collection. You can't paginate a collection - only a database query.

What are you trying to do, search categories by 'name'?

Only, it looks all wrong to me.

@sagar001 If anyone show me better way than my own than i will mark the ans as the best answer. :)

<GRINS>

You're actually extracting the height and width from 'file' and then doing a required check on file. If file is not present you'll get an exception and not the error message you want.

And...

function ($attribute, $value, $fail){
if($this->width < 1080 && $this->height < 1080) {
    $fail("Wallpaper's width or height must be greater than 1080px.");
   }
}

will only give an error message when both height AND width are less than 1080 - not the OR condition you're checking for.

Your solution isn't quite as good as you seem to think!

EDITED: This answer is not (quite) correct - see following posts.

Creating a new model using save() and then accessing the model's id is safe as the model will be populated with the auto-increment value assigned to it when it was persisted to the database.

In your FormRequest class you can override the prepareForValidation method and extract your dimensions there.

e.g.

protected function prepareForValidation()
{
    if( $this->has('file')) {
        $image = $this->file('file');
        list($width,$height) = getimagesize($image);
        $this->merge(['width' => $width, 'height' => $height]);
    }
}

public function rules()
{
    return [
       // Validation rules...
    ];
}

Width and Height are now available for the rules() method for validation.

This moves all of the logic out of your controller - nice and clean.

If you want your page to open in a new window/tab you can add the target="_blank" attribute to your link.

e.g.

<a target="_blank" class="nav-link" id="pp-apartments-tab" data-toggle="tab" href="#pp-apartments" role="tab" aria-controls="pp-apartments" aria-selected="true">
    <span> Apartaments </span>
    <span class="items-counter"> {{ $project->count }} </span>
    {{-- <i class="fad fa-building"></i> --}}
</a>

Can't you just use:

Poll::factory()->count(10)->make(['status' => 'A']);
Poll::factory()->count(10)->make(['status' => 'B']);
Poll::factory()->count(10)->make(['status' => 'C']);

Or are you after something else?

If you have a model and you want to access its methods statically, you could use a real time facade. See: https://laravel.com/docs/8.x/facades#real-time-facades

@jlrdw

it uses

$id = $query->getConnection()->getPdo()->lastInsertId($sequence);

I'm not sure it's always going to work unless he puts a temp small fraction of a second lock.

You're right.

The potential for an Id mismatch, however small, is there.

If Laravel + MySql is used in the standard way then accessing the model->id after a save() is perfectly safe and reliable.

However, if you have a heavy-traffic website and you've changed Laravel's default behaviour to pool MySql connections then you can run into problems doing this.

It may depend on your Plesk panel version.

On mine, I just select the domain I'm using and under "Dev Tools" there's a Git option (should show enabled or disabled). Obviously you need to enable it, set up the auth key for GitHub etc. and pull your repo into the correct folder.

When you go through the set up, the instructions are there for you.

You can choose any folder you like to upload the repo to (it doesn't have to go into httpdocs first) - then just point to the public folder when setting your document_root in your hosting settings.

It may depend on your Plesk panel version.

On mine, I just select the domain I'm using and under "Dev Tools" there's a Git option (should show enabled or disabled). Obviously you need to enable it, set up the auth key for GitHub etc. and pull your repo into the correct folder.

When you go through the set up, the instructions are there for you.

EDITED: This answer is not (quite) correct - see following posts.

Creating a new model using save() and then accessing the model's id is safe as the model will be populated with the auto-increment value assigned to it when it was persisted to the database.

I have a VPS that I use for my personal Laravel projects - Ubuntu server with Plesk panel (includes Git, Composer support, etc.)

Deploying, using Git, is a breeze. Likewise, updating via Composer is simply point and click.

I don't use them for personal projects, but setting up a dev server and staging server would be equally as simple and convenient.

So, I'd say give it a go on a VPS and only move to something more sophisticated if you need to.

When you print out your dropdown, you need to check whether the current category->id or the ids of its descendants matches the current dropdown->id and skip it if it does.

e.g. something like:

@foreach($categories as $category)
// Print out category info...
    @foreach($categories as $dropdown)
        @if($category->getIdList()->contains($dropdown->id))
            @continue
        @endif
        // Print option...
    @endforeach
@endforeach

Where $category->getIdList() is a recursive function that returns the id of the current category + its descendants' ids.

If either of weekend_inclusive or holiday_inclusive is not checked in the form, they won't be passed into the input array.

i.e. they won't be passed in as parameters with a value of "0" - they will simply be omitted unless their value is "1".

You could use:

'weekend_inclusive'                 => $request->weekend_inclusive[$key] ?? 0,
'holiday_inclusive'                 => $request->holiday_inclusive[$key] ?? 0,

To insert the zero when not set.

If either of weekend_inclusive or holiday_inclusive is not checked in the form, they won't be passed into the input array.

i.e. they won't be passed in as parameters with a value of "0" - they will simply be omitted unless their value is "1".

You could use:

'weekend_inclusive'                 => $request->weekend_inclusive[$key] ?? 0,
'holiday_inclusive'                 => $request->holiday_inclusive[$key] ?? 0,

To insert the zero when not set.

You can compare strings in a case-insensitive way without having to alter them:

if(strcasecmp('StrINg', 'string') == 0) {
    // OK to proceed...
}

Should

$threads = $threads->get();

be:

$threads = Thread::get();

Should

$threads = $threads->get();

be:

$threads = Thread::get();

@cac

Your code, as you've posted it, works OK for me.

What I would look at first is when you use: $e->workouts, is Laravel creating a database query and if so, what is it?

It should be the same query as what using $e->workouts()->get() produces when the workouts property isn't set.

Laravel doesn't have built-in support for limiting eager loaded relations - as far as I'm aware anyway.

If you NEED this functionality there's a package here: https://github.com/staudenmeir/eloquent-eager-limit

@sauravs012

Your User details aren't the default fields Laravel uses. Have you set the migration with the new fields properly, and have you changed the validation at all?

It's obviously not storing your user in the database so the problem is most likely with your input data.

@elb98rm

If you need to eager load the user's relations on every login, why not put an event listener on the Login Event and load them when it's fired? i.e. whenever a user logs in, their relations are automatically loaded for use in controllers etc.

That should work OK as long as you're not loading in too much data.

As the relationship is a One to Many, the inverse will mean that each category will only have one parent and each parent will have only one parent etc...

So in order to get a sequential list, the results will need to be looped through and built up. e.g.

$taxon = Taxon::with('parents')->find($id);

$parents = collect();
$currentTaxon = $taxon;

do {
    $parents[] = ['name' => $currentTaxon->name];
} while ($currentTaxon = $currentTaxon->parents);

Then just return $parents or $parents->reverse() depending on which order you want them in.

@foreach ($parents as $parent)
    {{ $parent['name'] }}
@endforeach

Should now work OK

Whichever one you like the most!

There's a light and a dark version of a nicely contrasted theme here: https://github.com/brendt/phpstorm-photon-theme

As the relationship is a One to Many, the inverse will mean that each category will only have one parent and each parent will have only one parent etc...

So in order to get a sequential list, the results will need to be looped through and built up. e.g.

$taxon = Taxon::with('parents')->find($id);

$parents = collect();
$currentTaxon = $taxon;

do {
    $parents[] = ['name' => $currentTaxon->name];
} while ($currentTaxon = $currentTaxon->parents);

Then just return $parents or $parents->reverse() depending on which order you want them in.

@foreach ($parents as $parent)
    {{ $parent['name'] }}
@endforeach

Should now work OK

For all parents try:

public function parents()
{
    return $this->belongsTo('App\Taxon', 'parent_id', 'id')->with('parents');
}

And for descendants:

public function descendants()
{
    return $this->hasMany('App\Taxon', 'parent_id', 'id')->with('descendants');
}

Just use:

'sponsor' => ['nullable', 'exists:users,user_name'],  

Just use:

'sponsor' => ['nullable', 'exists:users,user_name'],  

In Event.php your relationship should be:

public function user()
{
    $this->belongsTo(User::class);
{

Then your Event's show() method should be:

public function show($id)
{       
    $event = Event::with('user')->findOrFail($id);    
}

The user will be available via:

$event->user;

This is assuming a One to Many relationship: https://laravel.com/docs/7.x/eloquent-relationships#one-to-many

@dipcb05

In your controller, use:

$posts = Post::with('user')->get();

Then in your blade, using:

@foreach($posts as $post)
<h1> {{ $post->user->name }} </h1>
@endforeach

Should work OK.

You can add a static method to the model and return the primary key:

public static function primaryKey()
{
    return (new static())->getPrimaryKey();
}

and fetch it with: $primaryKey = ModelName::primaryKey();

Or...

You could hard code the key name into a constant, use that to set the field in the class, and then you'd be able to access the key without having to instantiate the class. e.g.

    class Test extends Model
    {
        const PRIMARYKEY = 'id';

        protected $primaryKey = self::PRIMARYKEY;
    }

It can be accessed with: $key = Test::PRIMARYKEY

You would have to change the const value if you ever changed the key but that's straightforward and unlikely to be required anyway once the key has been chosen.

You can add a static method to the model and return the primary key:

public static function primaryKey()
{
    return (new static())->getPrimaryKey();
}

and fetch it with: $primaryKey = ModelName::primaryKey();

@untymage

It really depends on how strict you want to be.

A unit test should:

• Test one thing and one thing only; and
• Not depend on other functionality in order to run; therefore
• Run independently.

So, a test that requires a database connection to pull in data that's required to test something is not actually a unit test (by these criteria): it's a feature test.

However, a test is a test and it's up to you as a developer whether you want to segregate tests into unit/feature.etc. based on strict definitions or take a more pragmatic approach and use some other criteria.

Most tests that you write when using a framework such as Laravel will be feature tests as you're almost always using the functionality of the framework (and trusting that it works as it's been tested itself independently) to some degree in your tests.

Siblings would all share a parent and cousins would all share a grandparent. It's the only way to relate records within one table. This approach is usually used with nested relationships: categories, subcategories, sub-subcategories, etc.

If you want to achieve the many-to-many set up you seem to be looking for, then just use a standard many-to-many set up - i.e. use a pivot table as normal to relate the table records to related records in the same table rather than another one.

There may be other solutions, but those are the simplest I would say.

If you do this in your test:

$this->withoutExceptionHandling();

$this->patch('some-path')->assertSomething();

It should work OK.

Off the top of my head, but I would expect it to work. You shouldn't need, indeed can't, turn off exception handling in the Response class.

My previous answer was incorrect - posting without checking first!

If you want to access a class constant with a variable use:

$var = "FIRSTNAME"

constant(ClassName::class."::".$var)

That should do it.

My previous answer was incorrect - posting without checking first!

If you want to access a class constant with a variable use:

$var = "FIRSTNAME"

constant(ClassName::class."::".$var)

That should do it.

This here in a_user_can_be_updated():

$user = factory(User::class)->create();

        $this->assertDatabaseMissing('users', [
            'id' => $user->id,
            'type' => User::TYPE_ADMIN,
            'name' => 'John Doe',
            'username' => 'JohnDoe',
            'email' => '[email protected]',
        ]);

Will fail because you're creating a user (i.e. saving them to the database) and then checking that they're missing from the database.

If you use:

$user = factory(User::class)->make();

instead of create, it will create a user in memory but not save it in the database.

NOTE (for anyone else who comes across this):

$status = User::where('status', $xyz)->update(['status'=>null]);

Will update ALL users whose status is $xyz - not just the one being targeted.

Normally, you set a constant in your model:

class ClassName extends Model
{
    const FIRSTNAME = "First";
    const SECONDNAME = "Second";
}

and then access them this way:

ClassName::FIRSTNAME

ClassName::SECONDNAME

ADDED: This answer is incorret

So, if your $variable equals `"FIRSTNAME" then you can access the constant with:

ClassName::$variable

and you'll get "First" returned. And so on...

If you run:

$status = User::where('status', $xyz);
$status ->delete();

It will delete all users whose status is $xyz (!)

What you need to do is an update query. i.e. find the user you're after and then update the field to the new value.

@grunburg

Post::paginate(10)

Will just fetch 10 posts. You need to get the user's posts

Try:

return new PostCollection($user->posts->paginate(10));

Or similar.