Laravel 5.5 . Re-send data with the replacement of existing ones - laravel

Question

there is a task:
1) the user will be retrieved and stored in the variable $user = User::find(1);
2) then the function displays experience;
3) In parallel with the operation of the function, the asynchronous method changes the experience by a random number every few seconds.
In the first function, the user experience is displayed once again. What will this conclusion be?
How can I implement the output on the page of deferred calculations?
Do I understand correctly that there should be the following sequence:
- on the page shows the experience;
- in parallel - every 3 seconds, the experience update is launched;
- in a minute (for example) the experience value is updated on the page?

Answer 1

There are 2 operations happening essentially independent of each other :
- Fetching and showing the information on frontend
- Updating the data in background
Each of this has some nitty gritty things like updates in X seconds etc which can be handled if we look at them as separate operations.
Frontend :
You can have simple route which gets the user using $user = User::find(1); as you mentioned in question and shows the information. That data will be what the respective user contains at the moment when the query is performed. It will have nothing to do with the background updates happening.
Then having requirements of fetching the updates, depending on which ever frontend javascript library you are using, you can have an Ajax call happening at an internal of X minutes depending on your refresh rate. This ajax call will get the updated information.
Handling background updates :
You can create an artisan command which has code to update the records.
Then you can schedule it to run every 3 minutes using laravel scheduling like :
$schedule->command('update:userexperience')->cron('3 * * * *');
And add * * * * * cd /path-to-your-project && php artisan schedule:run >> /dev/null 2>&1 in your server's crontab`
All above details are in documentation
Tips while scheduling command :
When you are updating users, if you re running just one query to update all users then its great. But if you have a logic which assigns a new value for each user in an individual row update, use chunk to load limited records at a time. This will help you keep the memory utilisation under a limit.
Testing before scheduling :
Doing it every 3 seconds is a very very small interval. I would suggest first run a command manually and check how much time it takes. If the backgrund process takes 2 seconds to complete one time, 3 second interval is tooo small.
Also, if the number of records in users table are increasing quickly, you need to revisit sometime later to increase the cron interval. It is good to keep that in mind.
Update :
The smallest unit in a cron is 1 minute. So to schedule it for every 3 seconds you can do inside app/Console/Kernel.php's schedule function :
$secondInterval = 3;
$totalJobs = 60 / $secondInterval;
for ($i = 0; $i < $totalJobs; $i++) {
$schedule->command('update:userexperience', [ '--delay'=> $secondInterval ])->everyMinute();
}
And then inside your command you delay :
<?php
namespace App\Console\Commands;
use Illuminate\Console\Command;
class UpdateUserExperienceCommand extends Command
{
/**
* The name and signature of the console command.
*
* #var string
*/
protected $signature = 'update:userexperience {--delay= : Number of seconds to delay command}';
/**
* The console command description.
*
* #var string
*/
protected $description = 'Import the CSVs';
/**
* Create a new command instance.
*
* #return void
*/
public function __construct()
{
parent::__construct();
}
/**
* Execute the command
*
* #return void
*/
public function handle()
{
sleep($this->option('delay'));
//update users
return;
}
}

Answer 2

Done.
Create a Job, which is designed for 30 requests within one and a half minutes. Every 3 seconds.
class UpdateUserExperienceJob implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
protected $user;
/**
* Create a new job instance.
*
* #param User $user
*/
public function __construct(User $user)
{
$this->user = $user;
}
/**
* Execute the job.
*
* #return void
*/
public function handle()
{
for ($i = 3; $i <= 90; $i += 3) {
sleep(3);
$this->user->update(['experience' => rand()]);
}
}
}
Create a method in the controller. Depending on the parameter repeatRequest depends on the launch of Job.
public function getExperience(): array
{
$user = User::find(request()->get('user_id'));
request()->get('repeatRequest') === 'true' ?: UpdateUserExperienceJob::dispatch($user);
return ['experience' => $user->experience];
}
Front implemented through Vue.js. In the component, when loading, we first get the current experience of the user, and then every 5 seconds we run a repeated request with a positive value of the repeatedRequest property. Due to the calculated properties, the value will change dynamically.
<template>
<div class="container">
<p>experience is updated every 5 seconds</p>
<p v-html="computedExperience"></p>
</div>
</template>
<script>
export default {
data: function () {
return {
experience: 0,
user_id: parseInt(document.URL.replace(/\D+/g,""))
}
},
mounted() {
this.firstExperience();
setInterval(this.repeatedExperience.bind(this), 5000);
},
computed: {
computedExperience() {
return this.experience;
},
},
methods: {
firstExperience: function () {
axios.get(document.URL + '/api', {
params: {
user_id: this.user_id,
repeatRequest: false
}
}).then((response) => {
this.experience = response.data.experience;
});
},
repeatedExperience: function () {
axios.get(document.URL + '/api', {
params: {
user_id: this.user_id,
repeatRequest: true
}
}).then((response) => {
this.experience = response.data.experience;
});
}
},
}
</script>