MongoDB::getCollectionNames() - Code Metrics - Inspection of "Split Rename, Add and remove collumns from MongoDB..." - Codexshaper/laravel-database-manager - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 47ed60...652a71 )

by CodexShaper
created 2020-01-05 15:00 UTC
MongoDB::getCollectionNames() A

↳ Parent: MongoDB
Complexity

Conditions	2
Paths	2
Size

Total Lines	9
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	5
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	9
ccs	0
cts	8
cp	0
crap	6
rs	10
<?php

namespace CodexShaper\DBM\Database\Drivers;

use CodexShaper\DBM\Database\Drivers\MongoDB\Index;
use CodexShaper\DBM\Models\CollectionField;
use CodexShaper\DBM\Models\DBM_Collection;
use CodexShaper\DBM\Traits\MongoConnection;
use Illuminate\Support\Facades\DB;

class MongoDB
{
    use MongoConnection;

    protected $db;
    protected $collection;
    protected $databaseName;
    protected $collectionName;

    public function command(array $command)
    {
        return static::getMongoClient()->{$this->admin}->command($command);
        return static::/** @scrutinizer ignore-call */ getMongoClient()->{$this->admin}->command($command);
    }

    public function renameCollection($fromNs, $toNs)
    {
        return $this->command(array('renameCollection' => $fromNs, 'to' => $toNs));
    }

    public function renameFields($collectionName, $fields)
    {
        $rename = [];
        foreach ($fields as $oldName => $newName) {
            $rename[$oldName] = $newName;
        }
        $update = array(
            '$rename' => $rename,
        );

        return $this->selectCollection($collectionName)->updateMany(array(), $update, array('upsert' => true));
    }

    public function getDB()
    {
        return DB::connection()->getMongoDB();
        return DB::connection()->/** @scrutinizer ignore-call */ getMongoDB();
    }

    public function getNamespace($databaseName, $collectionName)
    {
        return $databaseName . '.' . $collectionName;
    }

    public function getCollections()
    {
        return $this->getDB()->listCollections();
    }

    public function getCollectionNames()
    {
        $collections     = $this->getCollections();
        $collectionNames = [];
        foreach ($collections as $key => $collection) {
            $collectionNames[] = $collection->getName();
        }

        return $collectionNames;
    }

    public function hasCollection($collectionName)
    {
        return (in_array($collectionName, $this->getCollectionNames())) ? true : false;
    }

    public function createCollection($collectionName)
    {
        return $this->getDB()->createCollection($collectionName);
    }

    public function getCollection($collectionName)
    {
        return [
            'name'           => $collectionName,
            'oldName'        => $collectionName,
            'columns'        => $this->getColumns($collectionName),
            'indexes'        => Index::getIndexes($this->selectCollection($collectionName)),
            'foreignKeys'    => [],
            'primaryKeyName' => ['_id'],
            'options'        => [],
        ];
    }

    public function updateCollection($collection)
    {

        $newName        = $collection['name'];
        $oldName        = $collection['oldName'];
        $collectionName = $oldName;
        $connection     = config('database.default');
        $database       = config('database.connections.' . $connection . ".database");
        $fromNs         = $this->getNamespace($database, $oldName);
        $toNs           = $this->getNamespace($database, $newName);

        if ($newName != $oldName) {
            $this->renameCollection($fromNs, $toNs);
            $collectionName = $newName;
        }

        $this->setFields($collectionName, $this->getColumns($collectionName));
        Index::setIndexes($this->selectCollection($collectionName), $collection['indexes']);

        return true;

    }

    public function renameColumns($collectionName, $fields)
    {
        $collection = $this->selectCollection($collectionName);
        $renames    = [];
        foreach ($fields as $field) {
            if ($field->oldName != "") {
                if ($field->oldName != $field->name) {
                    $renames[$field->oldName] = $field->name;
                }

            }
        }
        $update = [];
        if (count($renames) > 0) {
            $update['$rename'] = $renames;
            $collection->updateMany(array(), $update, array('upsert' => true));
            $dbmCollection = DBM_Collection::where('name', $collectionName)->first();
            foreach ($renames as $oldName => $newName) {
                $collection_field = CollectionField::where([
                    'dbm_collection_id' => $dbmCollection->_id,
                    'old_name'          => $oldName,
                ])->first();
                $collection_field->old_name = $newName;
                $collection_field->update();
            }
        }
    }

    public function addColumns($collectionName)
    {
        $collection = $this->selectCollection($collectionName);
        $newFields  = $this->getColumnsName($collectionName);
        $update     = [];

        if ($collection->count() > 0) {
            foreach ($newFields as $newField) {
                $cursor   = $collection->find();
                $iterator = iterator_to_array($cursor);

                foreach ($iterator as $document) {
                    $columnNames = [];
                    $id          = "";
                    foreach ($document as $columnName => $columnValue) {
                        if (is_object($columnValue)) {
                            foreach ($columnValue as $key => $value) {
                                if ($columnName == '_id') {
                                    $id = $value;
                                }
                            }
                        }
                        $columnNames[] = $columnName;
                    }

                    if ($id != "" && !in_array($newField, $columnNames)) {
                        $update['$set'] = array($newField => "");
                        $collection->updateOne(
                            array("_id" => new \MongoDB\BSON\ObjectID($id)),
                            $update,
                            array('upsert' => true)
                        );
                    }
                }
            }

        }
    }

    public function removeColumns($collectionName)
    {
        $collection = $this->selectCollection($collectionName);
        $newFields  = $this->getColumnsName($collectionName);
        $columns    = $this->getCollectionColumns($collectionName);
        $update     = [];
        $unsets     = [];

        foreach ($columns as $column) {
            if (!in_array($column, $newFields)) {
                $unsets[$column] = "";
            }
        }

        if (count($unsets) > 0) {
            $update['$unset'] = $unsets;
            $collection->updateMany(array(), $update, array('upsert' => true));
        }
    }

    public function setFields($collectionName, $fields)
    {
        /*
         * Rename Columns
         */
        $this->renameColumns($collectionName, $fields);

        /*
         * Add Columns
         */
        $this->addColumns($collectionName);
        /*
         * Remove Columns
         */
        $this->removeColumns($collectionName);
        return true;
    }

    public function dropCollection($collectionName)
    {
        $this->getDB()->dropCollection($collectionName);
    }

    public function selectCollection($collectionName)
    {
        return $this->getDB()->selectCollection($collectionName);
    }

    public function getCollectionColumns($collectionName)
    {
        $cursor      = $this->selectCollection($collectionName)->find();
        $iterator    = iterator_to_array($cursor);
        $columnNames = [];

        foreach ($iterator as $document) {
            foreach ($document as $columnName => $columnValue) {
                $columnNames[] = $columnName;
            }
        }

        return array_values(array_unique($columnNames));
    }

    public function getColumns($collectionName)
    {
        $columns = [];

        if ($collection = DBM_Collection::where('name', $collectionName)->first()) {

            $fields = $collection->fields;
            foreach ($fields as $field) {
                $columns[] = (object) [
                    "name"          => $field->name,
                    "oldName"       => $field->old_name,
                    "type"          => [
                        "name" => $field->type,
                    ],
                    "autoincrement" => false,
                    "default"       => null,
                    "length"        => null,
                ];
            }
        } else {
            $fields = $this->getCollectionColumns($collectionName);
            foreach ($fields as $field) {
                $columns[] = (object) [
                    "name"          => $field,
                    "oldName"       => $field,
                    "type"          => [
                        "name" => "",
                    ],
                    "autoincrement" => false,
                    "default"       => null,
                    "length"        => null,
                ];
            }
        }

        return $columns;
    }

    public function getColumnsName($collectionName)
    {
        return DBM_Collection::where('name', $collectionName)->first()->fields->pluck('name')->toArray();
    }

}

Codexshaper / laravel-database-manager

Push — master ( 47ed60...652a71 )

MongoDB::getCollectionNames() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
