Longman\LaravelMultiLang\Console\ImportCommand

Complexity

Total Complexity

18

Size/Duplication

Total Lines	176
Duplicated Lines	9.66 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
C	handle()	8	32	7
C	import()	0	67	9
A	getDatabase()	9	9	2

<?php
/*
 * This file is part of the Laravel MultiLang package.
 *
 * (c) Avtandil Kikabidze aka LONGMAN <akalongman@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Longman\LaravelMultiLang\Console;

use App;
use Illuminate\Console\Command;
use Carbon\Carbon;
use InvalidArgumentException;
use Illuminate\Database\DatabaseManager as Database;
use Symfony\Component\Yaml\Yaml;

class ImportCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'multilang:import        
        {--path=storage/multilang : The path to multilang folder}
        {--lang= : Comma separated langs to import, default all}
        {--scope= : Comma separated scopes, default all}
        {--force : Force update existing texts in database}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Import texts in database from yml files.';

    /**
     * The name of texts table.
     *
     * @var string
     */
    protected $table;

    /**
     * The database connection instance.
     *
     * @var \Illuminate\Database\Connection
     */
    protected $db;

    /**
     * The path to texts files.
     *
     * @var string
     */
    protected $path;

    /**
     * The langs.
     *
     * @var array
     */
    protected $langs;

    /**
     * The available scopes.
     *
     * @var array
     */
    protected $scopes = ['global', 'site', 'admin'];

    /**
     * Execute the console command.
     *
     * @return mixed
     */
    public function handle()
    {
        $this->table = config('multilang.db.texts_table', 'texts');
        $this->db    = $this->getDatabase();

        $lang = $this->option('lang');
        if (! empty($lang)) {
            $this->langs = explode(',', $lang);
        }

        $scopes = $this->scopes;
        $scope  = $this->option('scope');
        if (! empty($scope)) {

This code seems to be duplicated across your project.

            $scopes = explode(',', $scope);
            foreach ($scopes as $scope) {
                if (! in_array($scope, $this->scopes)) {
                    throw new InvalidArgumentException('Scope "' . $scope . '" is not found! Available scopes is ' . implode(', ', $this->scopes));
                }
            }
        }

        $path       = $this->option('path', 'storage/multilang');

The call to ImportCommand::option() has too many arguments starting with 'storage/multilang'.

        $this->path = base_path($path);

It seems like $path defined by $this->option('path', 'storage/multilang') on line 101 can also be of type array; however, base_path() does only seem to accept string, maybe add an additional type check?

        if (! is_dir($this->path)) {
            throw new InvalidArgumentException('Folder "' . $this->path . '" is not accessible!');
        }

        $force = $this->option('force');
        foreach ($scopes as $scope) {
            $this->import($scope, $force);

$force is of type string|array, but the function expects a boolean.

        }
    }

    protected function import($scope = 'global', $force = false)
    {
        $path = $this->path . '/' . $scope . '.yml';
        if (! is_readable($path)) {
            $this->warn('File "' . $path . '" is not readable!');
            return false;
        }
        $data = Yaml::parse(file_get_contents($path));
        if (empty($data)) {
            $this->warn('File "' . $path . '" is empty!');
            return false;
        }

        $created_at = Carbon::now()->toDateTimeString();
        $updated_at = $created_at;
        $inserted   = 0;
        $updated    = 0;
        foreach ($data as $text) {

The expression $data of type array|string|object<stdClass> is not guaranteed to be traversable. How about adding an additional type check?

            $key = $text['key'];

            foreach ($text['texts'] as $lang => $value) {
                if (! empty($this->langs) && ! in_array($lang, $this->langs)) {
                    continue;
                }

                $row = $this->db
                    ->table($this->table)
                    ->where('scope', $scope)
                    ->where('key', $key)
                    ->first();

                if (empty($row)) {
                    // insert row
                    $ins               = [];
                    $ins['key']        = $key;
                    $ins['lang']       = $lang;
                    $ins['scope']      = $scope;
                    $ins['value']      = $value;
                    $ins['created_at'] = $created_at;
                    $ins['updated_at'] = $updated_at;
                    $this->db
                        ->table($this->table)
                        ->insert($ins);
                    $inserted++;
                } else {
                    if ($force) {
                        // force update row
                        $upd               = [];
                        $upd['key']        = $key;
                        $upd['lang']       = $lang;
                        $upd['scope']      = $scope;
                        $upd['value']      = $value;
                        $upd['updated_at'] = $updated_at;
                        $this->db
                            ->table($this->table)
                            ->where('key', $key)
                            ->where('lang', $lang)
                            ->where('scope', $scope)
                            ->update($upd);
                        $updated++;
                    }
                }
            }
        }

        $this->info('Import texts of "' . $scope . '" is finished. Inserted: ' . $inserted . ', Updated: ' . $updated);
    }

    /**
     * Get a database connection instance.
     *
     * @return \Illuminate\Database\Connection
     */
    protected function getDatabase()

This method seems to be duplicated in your project.

    {
        $connection = config('multilang.db.connection', 'default');
        $db         = App::make(Database::class);
        if ($connection == 'default') {
            return $db->connection();
        }
        return $db->connection($connection);
    }
}