NStackLoader::__construct() - Code Metrics - Inspection of "Translation loader for trans()" - nstack-io/laravel-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Pull Request — master (#3)

by Pawel
created 2019-09-10 11:31 UTC
NStackLoader::__construct() A

↳ Parent: NStackLoader
Complexity

Conditions	1
Paths	1
Size

Total Lines	10
Code Lines	7
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	7
c	1
b	0
f	0
nc	1
nop	3
dl	0
loc	10
rs	10
<?php

namespace NStack\Translation;

use Illuminate\Translation\FileLoader;
use Illuminate\Filesystem\Filesystem;
use NStack\NStack;
use NStack\Clients\LocalizeClient;
use NStack\Models\Resource;
use Illuminate\Support\Collection;
use NStack\Exceptions\NotFoundException;
use Carbon\Carbon;
use NStack\Exceptions\MissingMasterKeyException;

/**
 * NStackLoader for translations
 *
 * @author Pawel Wilk <[email protected]>
 *
 */
class NStackLoader extends FileLoader
{
    /**
     * @var NStack
     */
    protected $nstack;

    /**
     * @var LocalizeClient|null
     */
    protected $client;

    /**
     * @var string
     */
    protected $platform;

    /**
     * @var int
     */
    protected $cacheTime;

    /**
     * To avoid spamming the service, only retry the service if retry is above this count or sec below.
     *
     * @var int
     */
    protected $maxNetworkRetries;

    /**
     * To avoid spamming the service, only retry the service if retry is above the count above or this sec.
     *
     * @var int
     */
    protected $retryNetworkAfterSec;

    /**
     * @var \Illuminate\Database\Eloquent\Collection
     */
    protected $failedCarbons;

    /**
     * Constructor
     *
     * @param Filesystem $files
     * @param string $path
     * @param NStack $nstack
     */
    public function __construct(Filesystem $files, $path, NStack $nstack) {
        parent::__construct($files, $path);

        $this->nstack = $nstack;
        $this->failedCarbons = new Collection();

        $this->platform = config('nstack.platform');
        $this->cacheTime = config('nstack.cacheTime', 600);
        $this->maxNetworkRetries = config('nstack.maxNetworkRetries', 3);
        $this->retryNetworkAfterSec = config('nstack.retryNetworkAfterSec', 10);
    }

    /**
     * {@inheritDoc}
     * @see \Illuminate\Translation\LoaderInterface::load()
     */
    public function load($locale, $group, $namespace = null)
    {
        if (!is_null($namespace) && ($namespace != '*')) {
            return $this->loadNamespaced($locale, $group, $namespace);
        }

        if ($resource = $this->findResource($locale)) {
            $data = $this->loadTranslations($resource);

            if (isset($data[$group])) {
                return $data[$group];
            }
        }

        return parent::load($locale, $group);
    }

    /**
     * Download and cache translations
     *
     * @param Resource $resource
     * @param bool $refresh
     *
     * @return array
     */
    protected function loadTranslations(Resource $resource, $refresh = true)
    {
        $cacheKey = sprintf('nstack.resource.%d', $resource->getId());

        if (($data = \Cache::get($cacheKey, false)) && !$refresh) {
        if (($data = \Cache::/** @scrutinizer ignore-call */ get($cacheKey, false)) && !$refresh) {
            return $data;
        }

        $response = $this->request(function () use ($resource) {
            return $this->getClient()->showResource($resource->getUrl());
        });

        if (empty($response['data'])) {
            return [];
        }

        \Cache::put($cacheKey, $response['data'], $this->cacheTime);

        return $response['data'];
    }

    protected function request(\Closure $closure)
    {
        try {
            return $closure();
        } catch (\GuzzleHttp\Exception\GuzzleException $e) {
            if ($e->getCode() == 403) {
                throw new \Exception('Invalid credentials');
            }

            $this->performFail();
        }

        if ($this->shouldTryAgain()) {
            sleep(1);

            return $this->request($closure);
        } else {
            throw new \Exception('Maximum amount retries reached');
        }
    }

    /**
     * Find resource corresponding to locale
     *
     * @param string $locale
     * @return \NStack\Models\Resource|boolean
     */
    protected function findResource($locale)
    {
        foreach ($this->getResources() as $resource) { /* @var $resource \NStack\Models\Resource */
            if (locale_filter_matches($resource->getLanguage()->getLocale(), $locale)) {
                return $resource;
            }
        }

        return false;
    }

    /**
     * Return nstack localize client
     *
     * @return \NStack\Clients\LocalizeClient
     */
    protected function getClient()
    {
        if (is_null($this->client)) {
            $this->client = new LocalizeClient($this->nstack->getConfig());
        }

        return $this->client;
    }

    /**
     * Get available resources for platform
     *
     * @return Resource[]
     */
    protected function getResources($force = false)
    {
        $cacheKey = 'nstack.availableLocales';

        if (($data = \Cache::get($cacheKey, false)) && !$force) {
        if (($data = \Cache::/** @scrutinizer ignore-call */ get($cacheKey, false)) && !$force) {
            return $data;
        }

        $response = $this->request(function () {
            return $this->getClient()->indexResources($this->platform);
        });

        if (empty($response)) {
            return [];
        }

        \Cache::put($cacheKey, $response, $this->cacheTime);

        return $response;
    }

    /**
     * shouldTryAgain.
     *
     * @author Casper Rasmussen <[email protected]>
     * @return bool
     */
    private function shouldTryAgain()
    {
        if ($this->failedCarbons->count() < $this->maxNetworkRetries) {
            return true;
        }

        /** @var Carbon $carbon */
        $carbon = $this->failedCarbons->first();
        if ($carbon->diffInSeconds(Carbon::now()) >= $this->retryNetworkAfterSec) {
            return true;
        }

        return false;
    }

    /**
     * performFail.
     *
     * @author Casper Rasmussen <[email protected]>
     * @return void
     */
    private function performFail()
    {
        $this->failedCarbons->prepend(new Carbon());
        if ($this->failedCarbons->count() > 3) {
            $this->failedCarbons->pop();
        }
    }
}

nstack-io / laravel-sdk

GitHub Access Token became invalid

Pull Request — master (#3)

NStackLoader::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
