code review / idea to solve problem

I'd probably use a settings file for this and then load them into config on each request cycle.

You could use Spatie valuestore for this https://github.com/spatie/valuestore/#usage

Are those values something you can put in a config file instead of the database?

Another option is to cache the query, and then get the value from cache so you're not hitting the db constantly.

Storing them inside the redis was an idea of me too...unsure about this, but the idea of @snapey to use a file to store them doesn't sound that bad.

If you don't want to refactor a lot, an alternative is to just cache the row.

public function getPriceEUR()
{
    $factor = Cache::remember('factor', 5, function () {
            return SystemConfig::find(1)->value;
    });

    return intval($this->usd_price / $factor * 100);
}

Don't just put it in a file, thats not what I am saying.

It needs to be in memory so that if you iterate over 100 products you are not accessing the file 100 times.

In a service provider, or AppServiceProvider, load it from the file and store it in the app object or config element

@snapey

Would you suggest to use redis to store the value (redis is in use for sessions already) or what way do you suggest (I appreciate your replys that much, since they are very helpful)?

Using:

https://github.com/spatie/valuestore/#usage is storing them inside a file, so from my point of view, this would result in opening the file n times (as much as listings are generated), so the problem would just be moved from database to "file read I/O".

How about;

Install Valuestore composer require spatie/valuestore

In AppServiceProvider register method;

    public function register()
    {
        $this->app->singleton('valuestore', function () {
            return \Spatie\Valuestore\Valuestore::make(storage_path('app/settings.json'));
        });

        $values = $this->app->valuestore->all();

        $this->app->bind('settings', function () use($values) {
            return $values;
        });
    }

What we have in the app container is a singleton that points to the valuestore class. When you use that, you are directly interacting with the settings stored in the file.

When you use the settings bound to the app container, you are using a cached version of the values as they were at the start of the request cycle (as an associated array).

So instead of writing the current Euro rate to a database row, put it in the valuestore instead;

app('valuestore')->put('EUR', $rate)

and in your model when you want to apply this;

public function getPriceEUR()
{
    return intval($this->usd_price / app('settings')['EUR'] * 100);
}

By using settings and not valuestore the file will only be accessed once and not each time you iterate over the products.

Of course you now have a place where you can store other currencies or any other application settings.

@snapey rules.

Very clever way to get this done. Just of interested, why not using redis, your solution works fine.

If you have a redis server then use it as a cache, but it seems an overkill if you are not using it for anything else.