kevinbui

Sorry, I didn't hear Jeffrey said that its not gonna work for more complex form.

Good lesson! But @keydown is not gonna work with some form elements, such as select. Is there any other event that can be used for all form elements?

Cool. Just a note on that, you may say:

optional($user->credit)->amount;

So even if a user has no credit, it still return null and don’t raise any error.

Does that user has any credit?

Because you define a HasOne relationship so I think credit() could be a better function name.

public function credit()
{
    return $this->hasOne(Credit::class);
}

If you call the credit() function, you are gonna have a Illuminate\Database\Eloquent\Relations\HasOne object. If you want to access the credit model, pls say:

$user->credit->amount;

Interesting. Because we paginate the results, so $suppliers is an instance of Illuminate\Pagination\LengthAwarePaginator. Therefore, we are not able to use Higher Order Messages directly.

I have updated my answer slightly to consider that.

I have updated my answer accordingly.

So what data format did you have after using Rodenastyle/stream-parser?

That looks a bit complicated. What about storing products in the WorkSheet component and then pass it down to the ProductCart components?

// WorkSheet.vue
<template>
<div>
    <ProductCart :products="products"/>
</div>
</template>

<script>
    import ProductCart from './ProductCart'
 
    export default {
        components: {
            ProductCart
        },
        data() {
            return {
                products: []
            }
        }
    }
</script>

So the WorkSheet component already got the products in the beginning.

I am not sure what your question is but it may not necessary to do so. Laravel supports heaps of redirecting mechanisms, including this redirecting to actions.

This is a feature named Higher Order Message.

So the full form is gonna be:

$totalAmountDue = $child->user->payments->sum(function ($payment) use ($userId) {
    return $payment->usrAmountdue($child->user->id);
})

if ($totalAmountDue == 0) {
    ....
}

And of course, with higher order message, it become much simpler:

if ($child->user->payments->sum->usrAmountdue($userId) == 0) {
    ...
}

If I understand your question correctly, what you want may be something like this:

if ($child->user->payments->sum->usrAmountdue($userId) == 0) {
    ...
}

@abdulbazith That's an interesting point. Payments for a supplier could have different due dates, so it's not possible to group by suppliers. I have updated my answer above, I basically put all due dates in one cell.

You might simply use redirect

For better naming, I renamed the relationship from purchasetostore to payments.

public function payments()
{
    return $this->hasMany(PurchaseToStore::class, 'supplier_id');
}

We could make a query starting from the Supplier model, not the PurchaseToStore one.

$suppliers = Supplier::whereHas('payments', function ($query) use ($fromDate, $toDate) {
        $query->whereBetween('due_date', [$fromDate, $toDate]);
    })
    ->with(['payments' => function ()  use ($fromDate, $toDate) {
        $query->whereBetween('due_date', [$fromDate, $toDate]);
    }])
    ->paginate(50);

From the view (I assume that you use timestamp for the due_date field):

<thead>
    <tr>
        <th>S.No</th>
        <th>Supplier</th>
        <th>Due Dates</th>
        <th>Amount</th>
    </tr>
</thead>
<tbody>
@foreach($suppliers as $supplier)
    <tr>
        <td>{{$supplier->id}}</td>
        <td>{{$supplier->name}}</td>
        <td>{{
            $supplier->payments
                ->pluck('due_date')
                ->map
                ->format('d/m/Y')
                ->unique()
                ->implode(', ')
        }}</td>
        <td>{{$supplier->payments->sum('amount')}}</td>
    </tr>
@endforeach
</tbody>
<tfoot>
    <tr>
        <td colspan="4">Total: ${{$suppliers->getCollection()->map->payments->collapse()->sum('amount')}}</td>
    </tr>
</tfoot>

Is it alright to make the order field a sequential value? If so, we can make that auto incremented in the migration file:

Schema::create('course_items', function (Blueprint $table) {
    // ...
    $table->signedInteger('order')->autoIncrement();
    // ...
});

Please let me know @successdav so I can update my answer accordingly.

Could you share some code?

There is also a free course about optimisation:

https://serversforhackers.com/laravel-perf

I did the same task before and those are the two packages that I used:

https://github.com/barryvdh/laravel-dompdf

https://github.com/endroid/qr-code

You might try this:

$result = $thread->tags->groupBy(function ($tags) {
    return $tag->pivot->tag_type;
});

This would be a perfect case for accessor:

https://laravel.com/docs/5.8/eloquent-mutators#accessors-and-mutators

You could do something like:

use Illuminate\Support\Str;

public function getTempCodeAttribute($value)
{
    return "$value-" . Str::random(4);
}

"Learn" is a weird model name. In this context, I think CourseItem could be better.

Lets define a relationship in the Course model:

class Course
{
    public function courseItems()
    {
        return $this->hasMany(CourseItem::class);
    }
}

According to a very popular speech: https://www.youtube.com/watch?v=MF0jFKvS4SI

I love to rewrite routing and controller this way. I also to prefer using relationship and request helper function to create a new course item.

Route::post('/courses/{courseId}/course-items', '[email protected]');

class CourseCourseItemsController
{
    public function store(Course $course)
    {
        $this->validate(request(), ['body' => 'required|spamfree']);

        return $course->courseItems()->create(request()->only('body'));
    }
}

Setting the order of a course item could be done in a model event: https://laravel.com/docs/5.8/eloquent#events

My understanding is that if you are not able to find a course item with an order of 1, you create a new item with an order of 2. So lets create a creating event like this.

namespace App\Events;

class CourseItemCreating
{
    public $courseItem;

    public function __construct(CourseItem $courseItem)
    {
        $this->courseItem = $courseItem;
    }
}

And the listener:

namespace App\Listener;

class IncrementOrderIfNeeded
{
    public function handle(CourseItemCreating $event)
    {
        if (CourseItem::where('order', 1)->exists()) {
            $event->courseItem->order = 2;
        } else {
            $event->courseItem->order = 1;
        }
    }
}

Then lets bind the event to the listener.

class CourseItem
{
    protected $dispatchesEvents = [
        'creating' => CourseItemCreating::class,
    ];
}

class EventServiceProvider
{
    protected $listen = [
        CourseItemCreating::class => [IncrementOrderIfNeeded::class]
    ];
}

Could I see the controller action too?

Please go to Algolia Client Dashboard and enter the same search term to see if it actually works.

I think Martin's answer is close, but count is MySQL keyword, so its not accepted. Lets rename it to something else.

$dailyAverage = \DB::table('reviews')
            ->select(\DB::raw("to_char(date_trunc('day', created_at),'YYYY-MM-DD') as date, count(created_at) as     
            reviews_count"))
            ->whereIn('location_id', $locationIds)
            ->groupBy('date')
            ->avg('count');

Also, counting the created_at field is weird. I assume you want to count the number of reviews. So I rewrite it like this:

$dailyAverage = \DB::table('reviews')
            ->select(\DB::raw("to_char(date_trunc('day', created_at),'YYYY-MM-DD') as date, count(id) as     
            reviews_count"))
            ->whereIn('location_id', $locationIds)
            ->groupBy('date')
            ->avg('count');

What do you mean "distinct rows from the relation"? Each ticket only has ONE type.

I think this is a perfect use case for whereHas.

https://laravel.com/docs/5.8/eloquent-relationships#querying-relationship-existence.

So lets define a relationship in SpecificPurchaseBill model:

class SpecificPurchaseBill
{
    public function purchaseToStore()
    {
        return $this->belongsTo(PurchaseToStore::class);
    }
}

And then you might write a query like this (I have refactored a bit):

$all = SpecificPurchaseBill::where('hotel_id', Auth::user()->hotel_id)
    ->when(!empty(request('from')), function ($query) {
        return $query->whereBetween('d_date', [request('from_date'), request('to_date')]);
    })
    ->whereHas('purchaseToStore', function ($query) {
        $query->where('payment_status', 1);
    })
    ->orderBy('created_at', 'asc')
    ->get();

Thats really fast for 227 test cases.

You can simply say:

if(! $coin) return abort(404);

Can I see how you configure the route in web.php?

I don't think mapping a getter with param to a computed property is a good idea. Typically a computed property has no param:

https://vuex.vuejs.org/guide/getters.html#method-style-access

Lets use a method for the getter:

// I remove the mapState. getPageSettings is not a state to me.

methods: {
    getPage() {
         return this.$store.getters.getPageSettings(this.id)
    }
},
mounted () {
    // page is a piece of data for this component.
    this.page = this.getPage();
}

According to vuex documentation:

https://vuex.vuejs.org/guide/getters.html#method-style-access

We should use a method instead of a computed property for that getter:

// I assume the pageId is a prop.

methods: {
    getSettings() {
        return this.$store.getters.getPageSettings(this.pageId);
    }
}

I think we should not use computed properties with params.

According to your thread title, there are two approaches to do this.

The first approach is to eager load distinctive events for each session.

$sessions = Session::withCount([
    'events' => function ($query) {
        $query->distinct();
    }
])
->whereBetween('end_time', ['2018-05-19 04:42:00', '2019-05-19 04:42:00')
->get()

The second approach is to join two tables together:

$sessions = Session::selectRaw('sessions.*, COUNT(DISTINCT events.id) AS events_count')
->join('events', 'sessions.id', '=', 'events.session_id')
->whereBetween('sessions.end_time', ['2018-05-19 04:42:00', '2019-05-19 04:42:00')
->get()

I have also noticed that the time range you put is nothing (from '2018-05-19 04:42:00' to '2018-05-19 04:42:00'). So please update this time range as well.

Melbourne, Australia

Have you defined the route for that POST request?

What is $onlineUsers a collection of? Is that a collection of eloquent models?

I reckon you might change it this way:

    @if ($onlineUsers->pluck('name')->contains($comment->user->name))
    @endif

I assume that the table you are creating a query for named payments:

return Payment::where('payment_status', 'Cheq')
    ->whereBetween('created_at', [
        now()->startOfDay()->toDateTimeString(),
        now()->endOfDay()->toDateTimeString()
    ])->get();

Lets call your array $array and use collection to achieve the result:

$result = collect($array)->map(function ($subArray) {
    return $subArray['advisors'];
})
->map(function ($advisors) {
    $advisorNames = collect($advisors)->map(function ($advisorNames) {
        return implode(" ", $advisorNames);
    })->implode(', ');

    return ['advisor_name' => $advisorNames];
})
->values();

Hey mate,

You might be interested in those two lessons:

https://laracasts.com/series/lets-build-a-forum-with-laravel/episodes/25

https://laracasts.com/series/lets-build-a-forum-with-laravel/episodes/26

This is a pretty good approach to record activities.

You might do like this:

$comments = Comments::with('replies')->all();

Then:

<ParentComponent :comments="{{ $comments }}"></ParentComponent>

We are gonna use each comment inside the ParentComponent.vue:

// ParentComponent.vue

<template>
    <div>
        <ChildComponent  v-for="comment in comments" :comment="comment"/>
    <div>
</template>

<script>
import ChildComponent from './ChildComponent'


export default {
    props: [''comments"],
    components: {
        ChildComponent
    }
}
</script>

We don't need to pass a comment's replies to the ChildComponent because each reply already has a "replies" key with all of its replies.

That works! I also found a cool way to achieve this.

use Illuminate\Support\Collection;

...

$ticketsQuantity = $request->input('tickets_quantity');

Collection::times($ticketsQuantity, function ($number) {
    Ticket::create([
        'competition_id' => 1,
            'number' => $i,
            'price' => 120,
            'is_available' => true,
    ]);
});